Google Git
Sign in
coral / imx-board-wlan-src / e32d219a6c4eb6e636a5bd9c7dec8c1abbeddab0 / . / CORE / SME / src / csr / csrUtil.c
blob: 3104e75d4716fe5b956c3e56f58cde633dc44056 [file] [log] [blame]
/*
* Copyright (c) 2013, The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, 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.
*/
/*
* This file was originally distributed by Qualcomm Atheros, Inc.
* under proprietary terms before Copyright ownership was assigned
* to the Linux Foundation.
*/
/** ------------------------------------------------------------------------- *
------------------------------------------------------------------------- *
\file csrUtil.c
Implementation supporting routines for CSR.
Copyright (C) 2006 Airgo Networks, Incorporated
========================================================================== */
#include "aniGlobal.h"
#include "palApi.h"
#include "csrSupport.h"
#include "csrInsideApi.h"
#include "smsDebug.h"
#include "smeQosInternal.h"
#include "wlan_qct_wda.h"
#ifdef FEATURE_WLAN_CCX
#include "vos_utils.h"
#include "csrCcx.h"
#endif /* FEATURE_WLAN_CCX */
tANI_U8 csrWpaOui[][ CSR_WPA_OUI_SIZE ] = {
{ 0x00, 0x50, 0xf2, 0x00 },
{ 0x00, 0x50, 0xf2, 0x01 },
{ 0x00, 0x50, 0xf2, 0x02 },
{ 0x00, 0x50, 0xf2, 0x03 },
{ 0x00, 0x50, 0xf2, 0x04 },
{ 0x00, 0x50, 0xf2, 0x05 },
#ifdef FEATURE_WLAN_CCX
{ 0x00, 0x40, 0x96, 0x00 }, // CCKM
#endif /* FEATURE_WLAN_CCX */
};
tANI_U8 csrRSNOui[][ CSR_RSN_OUI_SIZE ] = {
{ 0x00, 0x0F, 0xAC, 0x00 }, // group cipher
{ 0x00, 0x0F, 0xAC, 0x01 }, // WEP-40 or RSN
{ 0x00, 0x0F, 0xAC, 0x02 }, // TKIP or RSN-PSK
{ 0x00, 0x0F, 0xAC, 0x03 }, // Reserved
{ 0x00, 0x0F, 0xAC, 0x04 }, // AES-CCMP
{ 0x00, 0x0F, 0xAC, 0x05 }, // WEP-104
{ 0x00, 0x40, 0x96, 0x00 }, // CCKM
{ 0x00, 0x0F, 0xAC, 0x06 } // BIP (encryption type) or RSN-PSK-SHA256 (authentication type)
};
#ifdef FEATURE_WLAN_WAPI
tANI_U8 csrWapiOui[][ CSR_WAPI_OUI_SIZE ] = {
{ 0x00, 0x14, 0x72, 0x00 }, // Reserved
{ 0x00, 0x14, 0x72, 0x01 }, // WAI certificate or SMS4
{ 0x00, 0x14, 0x72, 0x02 } // WAI PSK
};
#endif /* FEATURE_WLAN_WAPI */
tANI_U8 csrWmeInfoOui[ CSR_WME_OUI_SIZE ] = { 0x00, 0x50, 0xf2, 0x02 };
tANI_U8 csrWmeParmOui[ CSR_WME_OUI_SIZE ] = { 0x00, 0x50, 0xf2, 0x02 };
static tCsrIELenInfo gCsrIELengthTable[] = {
/* 000 */ { SIR_MAC_SSID_EID_MIN, SIR_MAC_SSID_EID_MAX },
/* 001 */ { SIR_MAC_RATESET_EID_MIN, SIR_MAC_RATESET_EID_MAX },
/* 002 */ { SIR_MAC_FH_PARAM_SET_EID_MIN, SIR_MAC_FH_PARAM_SET_EID_MAX },
/* 003 */ { SIR_MAC_DS_PARAM_SET_EID_MIN, SIR_MAC_DS_PARAM_SET_EID_MAX },
/* 004 */ { SIR_MAC_CF_PARAM_SET_EID_MIN, SIR_MAC_CF_PARAM_SET_EID_MAX },
/* 005 */ { SIR_MAC_TIM_EID_MIN, SIR_MAC_TIM_EID_MAX },
/* 006 */ { SIR_MAC_IBSS_PARAM_SET_EID_MIN, SIR_MAC_IBSS_PARAM_SET_EID_MAX },
/* 007 */ { SIR_MAC_COUNTRY_EID_MIN, SIR_MAC_COUNTRY_EID_MAX },
/* 008 */ { SIR_MAC_FH_PARAMS_EID_MIN, SIR_MAC_FH_PARAMS_EID_MAX },
/* 009 */ { SIR_MAC_FH_PATTERN_EID_MIN, SIR_MAC_FH_PATTERN_EID_MAX },
/* 010 */ { SIR_MAC_REQUEST_EID_MIN, SIR_MAC_REQUEST_EID_MAX },
/* 011 */ { SIR_MAC_QBSS_LOAD_EID_MIN, SIR_MAC_QBSS_LOAD_EID_MAX },
/* 012 */ { SIR_MAC_EDCA_PARAM_SET_EID_MIN, SIR_MAC_EDCA_PARAM_SET_EID_MAX },
/* 013 */ { SIR_MAC_TSPEC_EID_MIN, SIR_MAC_TSPEC_EID_MAX },
/* 014 */ { SIR_MAC_TCLAS_EID_MIN, SIR_MAC_TCLAS_EID_MAX },
/* 015 */ { SIR_MAC_QOS_SCHEDULE_EID_MIN, SIR_MAC_QOS_SCHEDULE_EID_MAX },
/* 016 */ { SIR_MAC_CHALLENGE_TEXT_EID_MIN, SIR_MAC_CHALLENGE_TEXT_EID_MAX },
/* 017 */ { 0, 255 },
/* 018 */ { 0, 255 },
/* 019 */ { 0, 255 },
/* 020 */ { 0, 255 },
/* 021 */ { 0, 255 },
/* 022 */ { 0, 255 },
/* 023 */ { 0, 255 },
/* 024 */ { 0, 255 },
/* 025 */ { 0, 255 },
/* 026 */ { 0, 255 },
/* 027 */ { 0, 255 },
/* 028 */ { 0, 255 },
/* 029 */ { 0, 255 },
/* 030 */ { 0, 255 },
/* 031 */ { 0, 255 },
/* 032 */ { SIR_MAC_PWR_CONSTRAINT_EID_MIN, SIR_MAC_PWR_CONSTRAINT_EID_MAX },
/* 033 */ { SIR_MAC_PWR_CAPABILITY_EID_MIN, SIR_MAC_PWR_CAPABILITY_EID_MAX },
/* 034 */ { SIR_MAC_TPC_REQ_EID_MIN, SIR_MAC_TPC_REQ_EID_MAX },
/* 035 */ { SIR_MAC_TPC_RPT_EID_MIN, SIR_MAC_TPC_RPT_EID_MAX },
/* 036 */ { SIR_MAC_SPRTD_CHNLS_EID_MIN, SIR_MAC_SPRTD_CHNLS_EID_MAX },
/* 037 */ { SIR_MAC_CHNL_SWITCH_ANN_EID_MIN, SIR_MAC_CHNL_SWITCH_ANN_EID_MAX },
/* 038 */ { SIR_MAC_MEAS_REQ_EID_MIN, SIR_MAC_MEAS_REQ_EID_MAX },
/* 039 */ { SIR_MAC_MEAS_RPT_EID_MIN, SIR_MAC_MEAS_RPT_EID_MAX },
/* 040 */ { SIR_MAC_QUIET_EID_MIN, SIR_MAC_QUIET_EID_MAX },
/* 041 */ { SIR_MAC_IBSS_DFS_EID_MIN, SIR_MAC_IBSS_DFS_EID_MAX },
/* 042 */ { SIR_MAC_ERP_INFO_EID_MIN, SIR_MAC_ERP_INFO_EID_MAX },
/* 043 */ { SIR_MAC_TS_DELAY_EID_MIN, SIR_MAC_TS_DELAY_EID_MAX },
/* 044 */ { SIR_MAC_TCLAS_PROC_EID_MIN, SIR_MAC_TCLAS_PROC_EID_MAX },
/* 045 */ { SIR_MAC_QOS_ACTION_EID_MIN, SIR_MAC_QOS_ACTION_EID_MAX },
/* 046 */ { SIR_MAC_QOS_CAPABILITY_EID_MIN, SIR_MAC_QOS_CAPABILITY_EID_MAX },
/* 047 */ { 0, 255 },
/* 048 */ { SIR_MAC_RSN_EID_MIN, SIR_MAC_RSN_EID_MAX },
/* 049 */ { 0, 255 },
/* 050 */ { SIR_MAC_EXTENDED_RATE_EID_MIN, SIR_MAC_EXTENDED_RATE_EID_MAX },
/* 051 */ { 0, 255 },
/* 052 */ { 0, 255 },
/* 053 */ { 0, 255 },
/* 054 */ { 0, 255 },
/* 055 */ { 0, 255 },
/* 056 */ { 0, 255 },
/* 057 */ { 0, 255 },
/* 058 */ { 0, 255 },
/* 059 */ { 0, 255 },
/* 060 */ { 0, 255 },
/* 061 */ { 0, 255 },
/* 062 */ { 0, 255 },
/* 063 */ { 0, 255 },
/* 064 */ { 0, 255 },
/* 065 */ { 0, 255 },
/* 066 */ { 0, 255 },
/* 067 */ { 0, 255 },
#ifdef FEATURE_WLAN_WAPI
/* 068 */ { DOT11F_EID_WAPI, DOT11F_IE_WAPI_MAX_LEN },
#else
/* 068 */ { 0, 255 },
#endif /* FEATURE_WLAN_WAPI */
/* 069 */ { 0, 255 },
/* 070 */ { 0, 255 },
/* 071 */ { 0, 255 },
/* 072 */ { 0, 255 },
/* 073 */ { 0, 255 },
/* 074 */ { 0, 255 },
/* 075 */ { 0, 255 },
/* 076 */ { 0, 255 },
/* 077 */ { 0, 255 },
/* 078 */ { 0, 255 },
/* 079 */ { 0, 255 },
/* 080 */ { 0, 255 },
/* 081 */ { 0, 255 },
/* 082 */ { 0, 255 },
/* 083 */ { 0, 255 },
/* 084 */ { 0, 255 },
/* 085 */ { 0, 255 },
/* 086 */ { 0, 255 },
/* 087 */ { 0, 255 },
/* 088 */ { 0, 255 },
/* 089 */ { 0, 255 },
/* 090 */ { 0, 255 },
/* 091 */ { 0, 255 },
/* 092 */ { 0, 255 },
/* 093 */ { 0, 255 },
/* 094 */ { 0, 255 },
/* 095 */ { 0, 255 },
/* 096 */ { 0, 255 },
/* 097 */ { 0, 255 },
/* 098 */ { 0, 255 },
/* 099 */ { 0, 255 },
/* 100 */ { 0, 255 },
/* 101 */ { 0, 255 },
/* 102 */ { 0, 255 },
/* 103 */ { 0, 255 },
/* 104 */ { 0, 255 },
/* 105 */ { 0, 255 },
/* 106 */ { 0, 255 },
/* 107 */ { 0, 255 },
/* 108 */ { 0, 255 },
/* 109 */ { 0, 255 },
/* 110 */ { 0, 255 },
/* 111 */ { 0, 255 },
/* 112 */ { 0, 255 },
/* 113 */ { 0, 255 },
/* 114 */ { 0, 255 },
/* 115 */ { 0, 255 },
/* 116 */ { 0, 255 },
/* 117 */ { 0, 255 },
/* 118 */ { 0, 255 },
/* 119 */ { 0, 255 },
/* 120 */ { 0, 255 },
/* 121 */ { 0, 255 },
/* 122 */ { 0, 255 },
/* 123 */ { 0, 255 },
/* 124 */ { 0, 255 },
/* 125 */ { 0, 255 },
/* 126 */ { 0, 255 },
/* 127 */ { 0, 255 },
/* 128 */ { 0, 255 },
/* 129 */ { 0, 255 },
/* 130 */ { 0, 255 },
/* 131 */ { 0, 255 },
/* 132 */ { 0, 255 },
/* 133 */ { 0, 255 },
/* 134 */ { 0, 255 },
/* 135 */ { 0, 255 },
/* 136 */ { 0, 255 },
/* 137 */ { 0, 255 },
/* 138 */ { 0, 255 },
/* 139 */ { 0, 255 },
/* 140 */ { 0, 255 },
/* 141 */ { 0, 255 },
/* 142 */ { 0, 255 },
/* 143 */ { 0, 255 },
/* 144 */ { 0, 255 },
/* 145 */ { 0, 255 },
/* 146 */ { 0, 255 },
/* 147 */ { 0, 255 },
/* 148 */ { 0, 255 },
/* 149 */ { 0, 255 },
/* 150 */ { 0, 255 },
/* 151 */ { 0, 255 },
/* 152 */ { 0, 255 },
/* 153 */ { 0, 255 },
/* 154 */ { 0, 255 },
/* 155 */ { 0, 255 },
/* 156 */ { 0, 255 },
/* 157 */ { 0, 255 },
/* 158 */ { 0, 255 },
/* 159 */ { 0, 255 },
/* 160 */ { 0, 255 },
/* 161 */ { 0, 255 },
/* 162 */ { 0, 255 },
/* 163 */ { 0, 255 },
/* 164 */ { 0, 255 },
/* 165 */ { 0, 255 },
/* 166 */ { 0, 255 },
/* 167 */ { 0, 255 },
/* 168 */ { 0, 255 },
/* 169 */ { 0, 255 },
/* 170 */ { 0, 255 },
/* 171 */ { 0, 255 },
/* 172 */ { 0, 255 },
/* 173 */ { 0, 255 },
/* 174 */ { 0, 255 },
/* 175 */ { 0, 255 },
/* 176 */ { 0, 255 },
/* 177 */ { 0, 255 },
/* 178 */ { 0, 255 },
/* 179 */ { 0, 255 },
/* 180 */ { 0, 255 },
/* 181 */ { 0, 255 },
/* 182 */ { 0, 255 },
/* 183 */ { 0, 255 },
/* 184 */ { 0, 255 },
/* 185 */ { 0, 255 },
/* 186 */ { 0, 255 },
/* 187 */ { 0, 255 },
/* 188 */ { 0, 255 },
/* 189 */ { 0, 255 },
/* 190 */ { 0, 255 },
/* 191 */ { 0, 255 },
/* 192 */ { 0, 255 },
/* 193 */ { 0, 255 },
/* 194 */ { 0, 255 },
/* 195 */ { 0, 255 },
/* 196 */ { 0, 255 },
/* 197 */ { 0, 255 },
/* 198 */ { 0, 255 },
/* 199 */ { 0, 255 },
/* 200 */ { 0, 255 },
/* 201 */ { 0, 255 },
/* 202 */ { 0, 255 },
/* 203 */ { 0, 255 },
/* 204 */ { 0, 255 },
/* 205 */ { 0, 255 },
/* 206 */ { 0, 255 },
/* 207 */ { 0, 255 },
/* 208 */ { 0, 255 },
/* 209 */ { 0, 255 },
/* 210 */ { 0, 255 },
/* 211 */ { 0, 255 },
/* 212 */ { 0, 255 },
/* 213 */ { 0, 255 },
/* 214 */ { 0, 255 },
/* 215 */ { 0, 255 },
/* 216 */ { 0, 255 },
/* 217 */ { 0, 255 },
/* 218 */ { 0, 255 },
/* 219 */ { 0, 255 },
/* 220 */ { 0, 255 },
/* 221 */ { SIR_MAC_WPA_EID_MIN, SIR_MAC_WPA_EID_MAX },
/* 222 */ { 0, 255 },
/* 223 */ { 0, 255 },
/* 224 */ { 0, 255 },
/* 225 */ { 0, 255 },
/* 226 */ { 0, 255 },
/* 227 */ { 0, 255 },
/* 228 */ { 0, 255 },
/* 229 */ { 0, 255 },
/* 230 */ { 0, 255 },
/* 231 */ { 0, 255 },
/* 232 */ { 0, 255 },
/* 233 */ { 0, 255 },
/* 234 */ { 0, 255 },
/* 235 */ { 0, 255 },
/* 236 */ { 0, 255 },
/* 237 */ { 0, 255 },
/* 238 */ { 0, 255 },
/* 239 */ { 0, 255 },
/* 240 */ { 0, 255 },
/* 241 */ { 0, 255 },
/* 242 */ { 0, 255 },
/* 243 */ { 0, 255 },
/* 244 */ { 0, 255 },
/* 245 */ { 0, 255 },
/* 246 */ { 0, 255 },
/* 247 */ { 0, 255 },
/* 248 */ { 0, 255 },
/* 249 */ { 0, 255 },
/* 250 */ { 0, 255 },
/* 251 */ { 0, 255 },
/* 252 */ { 0, 255 },
/* 253 */ { 0, 255 },
/* 254 */ { 0, 255 },
/* 255 */ { SIR_MAC_ANI_WORKAROUND_EID_MIN, SIR_MAC_ANI_WORKAROUND_EID_MAX }
};
#if 0
//Don't not insert entry into the table, put it to the end. If you have to insert, make sure it is also
//reflected in eCsrCountryIndex
static tCsrCountryInfo gCsrCountryInfo[eCSR_NUM_COUNTRY_INDEX] =
{
{REG_DOMAIN_FCC, {'U', 'S', ' '}}, //USA/******The "US" MUST be at index 0*******/
{REG_DOMAIN_WORLD, {'A', 'D', ' '}}, //ANDORRA
{REG_DOMAIN_WORLD, {'A', 'E', ' '}}, //UAE
{REG_DOMAIN_WORLD, {'A', 'F', ' '}}, //AFGHANISTAN
{REG_DOMAIN_WORLD, {'A', 'G', ' '}}, //ANTIGUA AND BARBUDA
{REG_DOMAIN_WORLD, {'A', 'I', ' '}}, //ANGUILLA
{REG_DOMAIN_HI_5GHZ, {'A', 'L', ' '}}, //ALBANIA
{REG_DOMAIN_WORLD, {'A', 'M', ' '}}, //ARMENIA
{REG_DOMAIN_WORLD, {'A', 'N', ' '}}, //NETHERLANDS ANTILLES
{REG_DOMAIN_WORLD, {'A', 'O', ' '}}, //ANGOLA
{REG_DOMAIN_WORLD, {'A', 'Q', ' '}}, //ANTARCTICA
{REG_DOMAIN_HI_5GHZ, {'A', 'R', ' '}}, //ARGENTINA
{REG_DOMAIN_FCC, {'A', 'S', ' '}}, //AMERICAN SOMOA
{REG_DOMAIN_ETSI, {'A', 'T', ' '}}, //AUSTRIA
{REG_DOMAIN_ETSI, {'A', 'U', ' '}}, //AUSTRALIA
{REG_DOMAIN_WORLD, {'A', 'W', ' '}}, //ARUBA
{REG_DOMAIN_WORLD, {'A', 'X', ' '}}, //ALAND ISLANDS
{REG_DOMAIN_WORLD, {'A', 'Z', ' '}}, //AZERBAIJAN
{REG_DOMAIN_WORLD, {'B', 'A', ' '}}, //BOSNIA AND HERZEGOVINA
{REG_DOMAIN_WORLD, {'B', 'B', ' '}}, //BARBADOS
{REG_DOMAIN_WORLD, {'B', 'D', ' '}}, //BANGLADESH
{REG_DOMAIN_ETSI, {'B', 'E', ' '}}, //BELGIUM
{REG_DOMAIN_WORLD, {'B', 'F', ' '}}, //BURKINA FASO
{REG_DOMAIN_HI_5GHZ, {'B', 'G', ' '}}, //BULGARIA
{REG_DOMAIN_WORLD, {'B', 'H', ' '}}, //BAHRAIN
{REG_DOMAIN_WORLD, {'B', 'I', ' '}}, //BURUNDI
{REG_DOMAIN_WORLD, {'B', 'J', ' '}}, //BENIN
{REG_DOMAIN_WORLD, {'B', 'L', ' '}}, //SAINT BARTHELEMY
{REG_DOMAIN_ETSI, {'B', 'M', ' '}}, //BERMUDA
{REG_DOMAIN_WORLD, {'B', 'N', ' '}}, //BRUNEI DARUSSALAM
{REG_DOMAIN_WORLD, {'B', 'O', ' '}}, //BOLIVIA
{REG_DOMAIN_WORLD, {'B', 'R', ' '}}, //BRAZIL
{REG_DOMAIN_WORLD, {'B', 'S', ' '}}, //BAHAMAS
{REG_DOMAIN_WORLD, {'B', 'T', ' '}}, //BHUTAN
{REG_DOMAIN_WORLD, {'B', 'V', ' '}}, //BOUVET ISLAND
{REG_DOMAIN_WORLD, {'B', 'W', ' '}}, //BOTSWANA
{REG_DOMAIN_WORLD, {'B', 'Y', ' '}}, //BELARUS
{REG_DOMAIN_WORLD, {'B', 'Z', ' '}}, //BELIZE
{REG_DOMAIN_FCC, {'C', 'A', ' '}}, //CANADA
{REG_DOMAIN_WORLD, {'C', 'C', ' '}}, //COCOS (KEELING) ISLANDS
{REG_DOMAIN_WORLD, {'C', 'D', ' '}}, //CONGO, THE DEMOCRATIC REPUBLIC OF THE
{REG_DOMAIN_WORLD, {'C', 'F', ' '}}, //CENTRAL AFRICAN REPUBLIC
{REG_DOMAIN_WORLD, {'C', 'G', ' '}}, //CONGO
{REG_DOMAIN_ETSI, {'C', 'H', ' '}}, //SWITZERLAND
{REG_DOMAIN_WORLD, {'C', 'I', ' '}}, //COTE D'IVOIRE
{REG_DOMAIN_WORLD, {'C', 'K', ' '}}, //COOK ISLANDS
{REG_DOMAIN_WORLD, {'C', 'L', ' '}}, //CHILE
{REG_DOMAIN_WORLD, {'C', 'M', ' '}}, //CAMEROON
{REG_DOMAIN_HI_5GHZ, {'C', 'N', ' '}}, //CHINA
{REG_DOMAIN_WORLD, {'C', 'O', ' '}}, //COLOMBIA
{REG_DOMAIN_WORLD, {'C', 'R', ' '}}, //COSTA RICA
{REG_DOMAIN_WORLD, {'C', 'U', ' '}}, //CUBA
{REG_DOMAIN_WORLD, {'C', 'V', ' '}}, //CAPE VERDE
{REG_DOMAIN_WORLD, {'C', 'X', ' '}}, //CHRISTMAS ISLAND
{REG_DOMAIN_WORLD, {'C', 'Y', ' '}}, //CYPRUS
{REG_DOMAIN_HI_5GHZ, {'C', 'Z', ' '}}, //CZECH REPUBLIC
{REG_DOMAIN_ETSI, {'D', 'E', ' '}}, //GERMANY
{REG_DOMAIN_WORLD, {'D', 'J', ' '}}, //DJIBOUTI
{REG_DOMAIN_ETSI, {'D', 'K', ' '}}, //DENMARK
{REG_DOMAIN_WORLD, {'D', 'M', ' '}}, //DOMINICA
{REG_DOMAIN_WORLD, {'D', 'O', ' '}}, //DOMINICAN REPUBLIC
{REG_DOMAIN_WORLD, {'D', 'Z', ' '}}, //ALGERIA
{REG_DOMAIN_WORLD, {'E', 'C', ' '}}, //ECUADOR
{REG_DOMAIN_HI_5GHZ, {'E', 'E', ' '}}, //ESTONIA
{REG_DOMAIN_WORLD, {'E', 'G', ' '}}, //EGYPT
{REG_DOMAIN_WORLD, {'E', 'H', ' '}}, //WESTERN SAHARA
{REG_DOMAIN_WORLD, {'E', 'R', ' '}}, //ERITREA
{REG_DOMAIN_ETSI, {'E', 'S', ' '}}, //SPAIN
{REG_DOMAIN_WORLD, {'E', 'T', ' '}}, //ETHIOPIA
{REG_DOMAIN_WORLD, {'F', 'I', ' '}}, //FINLAND
{REG_DOMAIN_WORLD, {'F', 'J', ' '}}, //FIJI
{REG_DOMAIN_WORLD, {'F', 'K', ' '}}, //FALKLAND ISLANDS (MALVINAS)
{REG_DOMAIN_WORLD, {'F', 'M', ' '}}, //MICRONESIA, FEDERATED STATES OF
{REG_DOMAIN_WORLD, {'F', 'O', ' '}}, //FAROE ISLANDS
{REG_DOMAIN_ETSI, {'F', 'R', ' '}}, //FRANCE
{REG_DOMAIN_WORLD, {'G', 'A', ' '}}, //GABON
{REG_DOMAIN_ETSI, {'G', 'B', ' '}}, //UNITED KINGDOM
{REG_DOMAIN_WORLD, {'G', 'D', ' '}}, //GRENADA
{REG_DOMAIN_HI_5GHZ, {'G', 'E', ' '}}, //GEORGIA
{REG_DOMAIN_WORLD, {'G', 'F', ' '}}, //FRENCH GUIANA
{REG_DOMAIN_ETSI, {'G', 'G', ' '}}, //GUERNSEY
{REG_DOMAIN_WORLD, {'G', 'H', ' '}}, //GHANA
{REG_DOMAIN_WORLD, {'G', 'I', ' '}}, //GIBRALTAR
{REG_DOMAIN_WORLD, {'G', 'L', ' '}}, //GREENLAND
{REG_DOMAIN_WORLD, {'G', 'M', ' '}}, //GAMBIA
{REG_DOMAIN_WORLD, {'G', 'N', ' '}}, //GUINEA
{REG_DOMAIN_WORLD, {'G', 'P', ' '}}, //GUADELOUPE
{REG_DOMAIN_WORLD, {'G', 'Q', ' '}}, //EQUATORIAL GUINEA
{REG_DOMAIN_ETSI, {'G', 'R', ' '}}, //GREECE
{REG_DOMAIN_WORLD, {'G', 'S', ' '}}, //SOUTH GEORGIA AND THE SOUTH SANDWICH ISLANDS
{REG_DOMAIN_WORLD, {'G', 'T', ' '}}, //GUATEMALA
{REG_DOMAIN_WORLD, {'G', 'U', ' '}}, //GUAM
{REG_DOMAIN_WORLD, {'G', 'W', ' '}}, //GUINEA-BISSAU
{REG_DOMAIN_WORLD, {'G', 'Y', ' '}}, //GUYANA
{REG_DOMAIN_WORLD, {'H', 'K', ' '}}, //HONGKONG
{REG_DOMAIN_WORLD, {'H', 'M', ' '}}, //HEARD ISLAND AND MCDONALD ISLANDS
{REG_DOMAIN_WORLD, {'H', 'N', ' '}}, //HONDURAS
{REG_DOMAIN_HI_5GHZ, {'H', 'R', ' '}}, //CROATIA
{REG_DOMAIN_WORLD, {'H', 'T', ' '}}, //HAITI
{REG_DOMAIN_HI_5GHZ, {'H', 'U', ' '}}, //HUNGARY
{REG_DOMAIN_APAC, {'I', 'D', ' '}}, //INDONESIA
{REG_DOMAIN_ETSI, {'I', 'E', ' '}}, //IRELAND
{REG_DOMAIN_WORLD, {'I', 'L', ' '}}, //ISREAL
{REG_DOMAIN_ETSI, {'I', 'M', ' '}}, //ISLE OF MAN
{REG_DOMAIN_WORLD, {'I', 'N', ' '}}, //INDIA
{REG_DOMAIN_ETSI, {'I', 'O', ' '}}, //BRITISH INDIAN OCEAN TERRITORY
{REG_DOMAIN_WORLD, {'I', 'Q', ' '}}, //IRAQ
{REG_DOMAIN_WORLD, {'I', 'R', ' '}}, //IRAN, ISLAMIC REPUBLIC OF
{REG_DOMAIN_WORLD, {'I', 'S', ' '}}, //ICELAND
{REG_DOMAIN_ETSI, {'I', 'T', ' '}}, //ITALY
{REG_DOMAIN_ETSI, {'J', 'E', ' '}}, //JERSEY
{REG_DOMAIN_WORLD, {'J', 'M', ' '}}, //JAMAICA
{REG_DOMAIN_WORLD, {'J', 'O', ' '}}, //JORDAN
{REG_DOMAIN_JAPAN, {'J', 'P', ' '}}, //JAPAN
{REG_DOMAIN_WORLD, {'K', 'E', ' '}}, //KENYA
{REG_DOMAIN_WORLD, {'K', 'G', ' '}}, //KYRGYZSTAN
{REG_DOMAIN_WORLD, {'K', 'H', ' '}}, //CAMBODIA
{REG_DOMAIN_WORLD, {'K', 'I', ' '}}, //KIRIBATI
{REG_DOMAIN_WORLD, {'K', 'M', ' '}}, //COMOROS
{REG_DOMAIN_WORLD, {'K', 'N', ' '}}, //SAINT KITTS AND NEVIS
{REG_DOMAIN_KOREA, {'K', 'P', ' '}}, //KOREA, DEMOCRATIC PEOPLE'S REPUBLIC OF
{REG_DOMAIN_KOREA, {'K', 'R', ' '}}, //KOREA, REPUBLIC OF
{REG_DOMAIN_WORLD, {'K', 'W', ' '}}, //KUWAIT
{REG_DOMAIN_WORLD, {'K', 'Y', ' '}}, //CAYMAN ISLANDS
{REG_DOMAIN_WORLD, {'K', 'Z', ' '}}, //KAZAKHSTAN
{REG_DOMAIN_WORLD, {'L', 'A', ' '}}, //LAO PEOPLE'S DEMOCRATIC REPUBLIC
{REG_DOMAIN_WORLD, {'L', 'B', ' '}}, //LEBANON
{REG_DOMAIN_WORLD, {'L', 'C', ' '}}, //SAINT LUCIA
{REG_DOMAIN_ETSI, {'L', 'I', ' '}}, //LIECHTENSTEIN
{REG_DOMAIN_WORLD, {'L', 'K', ' '}}, //SRI LANKA
{REG_DOMAIN_WORLD, {'L', 'R', ' '}}, //LIBERIA
{REG_DOMAIN_WORLD, {'L', 'S', ' '}}, //LESOTHO
{REG_DOMAIN_HI_5GHZ, {'L', 'T', ' '}}, //LITHUANIA
{REG_DOMAIN_ETSI, {'L', 'U', ' '}}, //LUXEMBOURG
{REG_DOMAIN_HI_5GHZ, {'L', 'V', ' '}}, //LATVIA
{REG_DOMAIN_WORLD, {'L', 'Y', ' '}}, //LIBYAN ARAB JAMAHIRIYA
{REG_DOMAIN_WORLD, {'M', 'A', ' '}}, //MOROCCO
{REG_DOMAIN_ETSI, {'M', 'C', ' '}}, //MONACO
{REG_DOMAIN_WORLD, {'M', 'D', ' '}}, //MOLDOVA, REPUBLIC OF
{REG_DOMAIN_WORLD, {'M', 'E', ' '}}, //MONTENEGRO
{REG_DOMAIN_WORLD, {'M', 'G', ' '}}, //MADAGASCAR
{REG_DOMAIN_WORLD, {'M', 'H', ' '}}, //MARSHALL ISLANDS
{REG_DOMAIN_WORLD, {'M', 'K', ' '}}, //MACEDONIA, THE FORMER YUGOSLAV REPUBLIC OF
{REG_DOMAIN_WORLD, {'M', 'L', ' '}}, //MALI
{REG_DOMAIN_WORLD, {'M', 'M', ' '}}, //MYANMAR
{REG_DOMAIN_HI_5GHZ, {'M', 'N', ' '}}, //MONGOLIA
{REG_DOMAIN_WORLD, {'M', 'O', ' '}}, //MACAO
{REG_DOMAIN_WORLD, {'M', 'P', ' '}}, //NORTHERN MARIANA ISLANDS
{REG_DOMAIN_WORLD, {'M', 'Q', ' '}}, //MARTINIQUE
{REG_DOMAIN_WORLD, {'M', 'R', ' '}}, //MAURITANIA
{REG_DOMAIN_WORLD, {'M', 'S', ' '}}, //MONTSERRAT
{REG_DOMAIN_WORLD, {'M', 'T', ' '}}, //MALTA
{REG_DOMAIN_WORLD, {'M', 'U', ' '}}, //MAURITIUS
{REG_DOMAIN_WORLD, {'M', 'V', ' '}}, //MALDIVES
{REG_DOMAIN_WORLD, {'M', 'W', ' '}}, //MALAWI
{REG_DOMAIN_WORLD, {'M', 'X', ' '}}, //MEXICO
{REG_DOMAIN_HI_5GHZ, {'M', 'Y', ' '}}, //MALAYSIA
{REG_DOMAIN_WORLD, {'M', 'Z', ' '}}, //MOZAMBIQUE
{REG_DOMAIN_WORLD, {'N', 'A', ' '}}, //NAMIBIA
{REG_DOMAIN_WORLD, {'N', 'C', ' '}}, //NEW CALEDONIA
{REG_DOMAIN_WORLD, {'N', 'E', ' '}}, //NIGER
{REG_DOMAIN_WORLD, {'N', 'F', ' '}}, //NORFOLD ISLAND
{REG_DOMAIN_WORLD, {'N', 'G', ' '}}, //NIGERIA
{REG_DOMAIN_WORLD, {'N', 'I', ' '}}, //NICARAGUA
{REG_DOMAIN_ETSI, {'N', 'L', ' '}}, //NETHERLANDS
{REG_DOMAIN_WORLD, {'N', 'O', ' '}}, //NORWAY
{REG_DOMAIN_WORLD, {'N', 'P', ' '}}, //NEPAL
{REG_DOMAIN_WORLD, {'N', 'R', ' '}}, //NAURU
{REG_DOMAIN_WORLD, {'N', 'U', ' '}}, //NIUE
{REG_DOMAIN_ETSI, {'N', 'Z', ' '}}, //NEW ZEALAND
{REG_DOMAIN_WORLD, {'O', 'M', ' '}}, //OMAN
{REG_DOMAIN_WORLD, {'P', 'A', ' '}}, //PANAMA
{REG_DOMAIN_WORLD, {'P', 'E', ' '}}, //PERU
{REG_DOMAIN_WORLD, {'P', 'F', ' '}}, //FRENCH POLYNESIA
{REG_DOMAIN_WORLD, {'P', 'G', ' '}}, //PAPUA NEW GUINEA
{REG_DOMAIN_WORLD, {'P', 'H', ' '}}, //PHILIPPINES
{REG_DOMAIN_WORLD, {'P', 'K', ' '}}, //PAKISTAN
{REG_DOMAIN_WORLD, {'P', 'L', ' '}}, //POLAND
{REG_DOMAIN_WORLD, {'P', 'M', ' '}}, //SAINT PIERRE AND MIQUELON
{REG_DOMAIN_WORLD, {'P', 'N', ' '}}, //PITCAIRN
{REG_DOMAIN_FCC, {'P', 'R', ' '}}, //PUERTO RICO
{REG_DOMAIN_WORLD, {'P', 'S', ' '}}, //PALESTINIAN TERRITORY, OCCUPIED
{REG_DOMAIN_ETSI, {'P', 'T', ' '}}, //PORTUGAL
{REG_DOMAIN_WORLD, {'P', 'W', ' '}}, //PALAU
{REG_DOMAIN_WORLD, {'P', 'Y', ' '}}, //PARAGUAY
{REG_DOMAIN_WORLD, {'Q', 'A', ' '}}, //QATAR
{REG_DOMAIN_WORLD, {'R', 'E', ' '}}, //REUNION
{REG_DOMAIN_HI_5GHZ, {'R', 'O', ' '}}, //ROMANIA
{REG_DOMAIN_HI_5GHZ, {'R', 'S', ' '}}, //SERBIA
{REG_DOMAIN_WORLD, {'R', 'U', ' '}}, //RUSSIA
{REG_DOMAIN_WORLD, {'R', 'W', ' '}}, //RWANDA
{REG_DOMAIN_WORLD, {'S', 'A', ' '}}, //SAUDI ARABIA
{REG_DOMAIN_WORLD, {'S', 'B', ' '}}, //SOLOMON ISLANDS
{REG_DOMAIN_ETSI, {'S', 'C', ' '}}, //SEYCHELLES
{REG_DOMAIN_WORLD, {'S', 'D', ' '}}, //SUDAN
{REG_DOMAIN_ETSI, {'S', 'E', ' '}}, //SWEDEN
{REG_DOMAIN_APAC, {'S', 'G', ' '}}, //SINGAPORE
{REG_DOMAIN_WORLD, {'S', 'H', ' '}}, //SAINT HELENA
{REG_DOMAIN_HI_5GHZ, {'S', 'I', ' '}}, //SLOVENNIA
{REG_DOMAIN_WORLD, {'S', 'J', ' '}}, //SVALBARD AND JAN MAYEN
{REG_DOMAIN_HI_5GHZ, {'S', 'K', ' '}}, //SLOVAKIA
{REG_DOMAIN_WORLD, {'S', 'L', ' '}}, //SIERRA LEONE
{REG_DOMAIN_WORLD, {'S', 'M', ' '}}, //SAN MARINO
{REG_DOMAIN_WORLD, {'S', 'N', ' '}}, //SENEGAL
{REG_DOMAIN_WORLD, {'S', 'O', ' '}}, //SOMALIA
{REG_DOMAIN_WORLD, {'S', 'R', ' '}}, //SURINAME
{REG_DOMAIN_WORLD, {'S', 'T', ' '}}, //SAO TOME AND PRINCIPE
{REG_DOMAIN_WORLD, {'S', 'V', ' '}}, //EL SALVADOR
{REG_DOMAIN_WORLD, {'S', 'Y', ' '}}, //SYRIAN ARAB REPUBLIC
{REG_DOMAIN_WORLD, {'S', 'Z', ' '}}, //SWAZILAND
{REG_DOMAIN_WORLD, {'T', 'C', ' '}}, //TURKS AND CAICOS ISLANDS
{REG_DOMAIN_WORLD, {'T', 'D', ' '}}, //CHAD
{REG_DOMAIN_WORLD, {'T', 'F', ' '}}, //FRENCH SOUTHERN TERRITORIES
{REG_DOMAIN_WORLD, {'T', 'G', ' '}}, //TOGO
{REG_DOMAIN_WORLD, {'T', 'H', ' '}}, //THAILAND
{REG_DOMAIN_WORLD, {'T', 'J', ' '}}, //TAJIKISTAN
{REG_DOMAIN_WORLD, {'T', 'K', ' '}}, //TOKELAU
{REG_DOMAIN_WORLD, {'T', 'L', ' '}}, //TIMOR-LESTE
{REG_DOMAIN_WORLD, {'T', 'M', ' '}}, //TURKMENISTAN
{REG_DOMAIN_WORLD, {'T', 'N', ' '}}, //TUNISIA
{REG_DOMAIN_WORLD, {'T', 'O', ' '}}, //TONGA
{REG_DOMAIN_WORLD, {'T', 'R', ' '}}, //TURKEY
{REG_DOMAIN_WORLD, {'T', 'T', ' '}}, //TRINIDAD AND TOBAGO
{REG_DOMAIN_WORLD, {'T', 'V', ' '}}, //TUVALU
{REG_DOMAIN_HI_5GHZ, {'T', 'W', ' '}}, //TAIWAN, PROVINCE OF CHINA
{REG_DOMAIN_WORLD, {'T', 'Z', ' '}}, //TANZANIA, UNITED REPUBLIC OF
{REG_DOMAIN_HI_5GHZ, {'U', 'A', ' '}}, //UKRAINE
{REG_DOMAIN_WORLD, {'U', 'G', ' '}}, //UGANDA
{REG_DOMAIN_FCC, {'U', 'M', ' '}}, //UNITED STATES MINOR OUTLYING ISLANDS
{REG_DOMAIN_WORLD, {'U', 'Y', ' '}}, //URUGUAY
{REG_DOMAIN_HI_5GHZ, {'U', 'Z', ' '}}, //UZBEKISTAN
{REG_DOMAIN_ETSI, {'V', 'A', ' '}}, //HOLY SEE (VATICAN CITY STATE)
{REG_DOMAIN_WORLD, {'V', 'C', ' '}}, //SAINT VINCENT AND THE GRENADINES
{REG_DOMAIN_HI_5GHZ, {'V', 'E', ' '}}, //VENEZUELA
{REG_DOMAIN_ETSI, {'V', 'G', ' '}}, //VIRGIN ISLANDS, BRITISH
{REG_DOMAIN_FCC, {'V', 'I', ' '}}, //VIRGIN ISLANDS, US
{REG_DOMAIN_WORLD, {'V', 'N', ' '}}, //VIET NAM
{REG_DOMAIN_WORLD, {'V', 'U', ' '}}, //VANUATU
{REG_DOMAIN_WORLD, {'W', 'F', ' '}}, //WALLIS AND FUTUNA
{REG_DOMAIN_WORLD, {'W', 'S', ' '}}, //SOMOA
{REG_DOMAIN_WORLD, {'Y', 'E', ' '}}, //YEMEN
{REG_DOMAIN_WORLD, {'Y', 'T', ' '}}, //MAYOTTE
{REG_DOMAIN_WORLD, {'Z', 'A', ' '}}, //SOUTH AFRICA
{REG_DOMAIN_WORLD, {'Z', 'M', ' '}}, //ZAMBIA
{REG_DOMAIN_WORLD, {'Z', 'W', ' '}}, //ZIMBABWE
{REG_DOMAIN_KOREA, {'K', '1', ' '}}, //Korea alternate 1
{REG_DOMAIN_KOREA, {'K', '2', ' '}}, //Korea alternate 2
{REG_DOMAIN_KOREA, {'K', '3', ' '}}, //Korea alternate 3
{REG_DOMAIN_KOREA, {'K', '4', ' '}}, //Korea alternate 4
};
//The channels listed here doesn't mean they are valid channels for certain domain. They are here only to present
//whether they should be passive scanned.
tCsrDomainChnInfo gCsrDomainChnInfo[NUM_REG_DOMAINS] =
{
//REG_DOMAIN_FCC
{
REG_DOMAIN_FCC,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_PASSIVE_SCAN},
{56, eSIR_PASSIVE_SCAN},
{60, eSIR_PASSIVE_SCAN},
{64, eSIR_PASSIVE_SCAN},
//5470 to 5725
{100, eSIR_PASSIVE_SCAN},
{104, eSIR_PASSIVE_SCAN},
{108, eSIR_PASSIVE_SCAN},
{112, eSIR_PASSIVE_SCAN},
{116, eSIR_PASSIVE_SCAN},
{120, eSIR_PASSIVE_SCAN},
{124, eSIR_PASSIVE_SCAN},
{128, eSIR_PASSIVE_SCAN},
{132, eSIR_PASSIVE_SCAN},
{136, eSIR_PASSIVE_SCAN},
{140, eSIR_PASSIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_ETSI
{
REG_DOMAIN_ETSI,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_PASSIVE_SCAN},
{56, eSIR_PASSIVE_SCAN},
{60, eSIR_PASSIVE_SCAN},
{64, eSIR_PASSIVE_SCAN},
//5470 to 5725
{100, eSIR_PASSIVE_SCAN},
{104, eSIR_PASSIVE_SCAN},
{108, eSIR_PASSIVE_SCAN},
{112, eSIR_PASSIVE_SCAN},
{116, eSIR_PASSIVE_SCAN},
{120, eSIR_PASSIVE_SCAN},
{124, eSIR_PASSIVE_SCAN},
{128, eSIR_PASSIVE_SCAN},
{132, eSIR_PASSIVE_SCAN},
{136, eSIR_PASSIVE_SCAN},
{140, eSIR_PASSIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_JAPAN
{
REG_DOMAIN_JAPAN,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_PASSIVE_SCAN},
{56, eSIR_PASSIVE_SCAN},
{60, eSIR_PASSIVE_SCAN},
{64, eSIR_PASSIVE_SCAN},
//5470 to 5725
{100, eSIR_PASSIVE_SCAN},
{104, eSIR_PASSIVE_SCAN},
{108, eSIR_PASSIVE_SCAN},
{112, eSIR_PASSIVE_SCAN},
{116, eSIR_PASSIVE_SCAN},
{120, eSIR_PASSIVE_SCAN},
{124, eSIR_PASSIVE_SCAN},
{128, eSIR_PASSIVE_SCAN},
{132, eSIR_PASSIVE_SCAN},
{136, eSIR_PASSIVE_SCAN},
{140, eSIR_PASSIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_WORLD
{
REG_DOMAIN_WORLD,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_ACTIVE_SCAN},
{56, eSIR_ACTIVE_SCAN},
{60, eSIR_ACTIVE_SCAN},
{64, eSIR_ACTIVE_SCAN},
//5470 to 5725
{100, eSIR_ACTIVE_SCAN},
{104, eSIR_ACTIVE_SCAN},
{108, eSIR_ACTIVE_SCAN},
{112, eSIR_ACTIVE_SCAN},
{116, eSIR_ACTIVE_SCAN},
{120, eSIR_ACTIVE_SCAN},
{124, eSIR_ACTIVE_SCAN},
{128, eSIR_ACTIVE_SCAN},
{132, eSIR_ACTIVE_SCAN},
{136, eSIR_ACTIVE_SCAN},
{140, eSIR_ACTIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_N_AMER_EXC_FCC
{
REG_DOMAIN_N_AMER_EXC_FCC,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_PASSIVE_SCAN},
{56, eSIR_PASSIVE_SCAN},
{60, eSIR_PASSIVE_SCAN},
{64, eSIR_PASSIVE_SCAN},
//5470 to 5725
{100, eSIR_ACTIVE_SCAN},
{104, eSIR_ACTIVE_SCAN},
{108, eSIR_ACTIVE_SCAN},
{112, eSIR_ACTIVE_SCAN},
{116, eSIR_ACTIVE_SCAN},
{120, eSIR_ACTIVE_SCAN},
{124, eSIR_ACTIVE_SCAN},
{128, eSIR_ACTIVE_SCAN},
{132, eSIR_ACTIVE_SCAN},
{136, eSIR_ACTIVE_SCAN},
{140, eSIR_ACTIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_APAC
{
REG_DOMAIN_APAC,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_PASSIVE_SCAN},
{56, eSIR_PASSIVE_SCAN},
{60, eSIR_PASSIVE_SCAN},
{64, eSIR_PASSIVE_SCAN},
//5470 to 5725
{100, eSIR_ACTIVE_SCAN},
{104, eSIR_ACTIVE_SCAN},
{108, eSIR_ACTIVE_SCAN},
{112, eSIR_ACTIVE_SCAN},
{116, eSIR_ACTIVE_SCAN},
{120, eSIR_ACTIVE_SCAN},
{124, eSIR_ACTIVE_SCAN},
{128, eSIR_ACTIVE_SCAN},
{132, eSIR_ACTIVE_SCAN},
{136, eSIR_ACTIVE_SCAN},
{140, eSIR_ACTIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_KOREA
{
REG_DOMAIN_KOREA,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_PASSIVE_SCAN},
{56, eSIR_PASSIVE_SCAN},
{60, eSIR_PASSIVE_SCAN},
{64, eSIR_PASSIVE_SCAN},
//5470 to 5725
{100, eSIR_PASSIVE_SCAN},
{104, eSIR_PASSIVE_SCAN},
{108, eSIR_PASSIVE_SCAN},
{112, eSIR_PASSIVE_SCAN},
{116, eSIR_PASSIVE_SCAN},
{120, eSIR_PASSIVE_SCAN},
{124, eSIR_PASSIVE_SCAN},
{128, eSIR_PASSIVE_SCAN},
{132, eSIR_PASSIVE_SCAN},
{136, eSIR_PASSIVE_SCAN},
{140, eSIR_PASSIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_HI_5GHZ
{
REG_DOMAIN_HI_5GHZ,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_ACTIVE_SCAN},
{56, eSIR_ACTIVE_SCAN},
{60, eSIR_ACTIVE_SCAN},
{64, eSIR_ACTIVE_SCAN},
//5470 to 5725
{100, eSIR_ACTIVE_SCAN},
{104, eSIR_ACTIVE_SCAN},
{108, eSIR_ACTIVE_SCAN},
{112, eSIR_ACTIVE_SCAN},
{116, eSIR_ACTIVE_SCAN},
{120, eSIR_ACTIVE_SCAN},
{124, eSIR_ACTIVE_SCAN},
{128, eSIR_ACTIVE_SCAN},
{132, eSIR_ACTIVE_SCAN},
{136, eSIR_ACTIVE_SCAN},
{140, eSIR_ACTIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
//REG_DOMAIN_NO_5GHZ
{
REG_DOMAIN_NO_5GHZ,
45, //Num channels
//Channels
{
//5GHz
//5180 - 5240
{36, eSIR_ACTIVE_SCAN},
{40, eSIR_ACTIVE_SCAN},
{44, eSIR_ACTIVE_SCAN},
{48, eSIR_ACTIVE_SCAN},
//5250 to 5350
{52, eSIR_ACTIVE_SCAN},
{56, eSIR_ACTIVE_SCAN},
{60, eSIR_ACTIVE_SCAN},
{64, eSIR_ACTIVE_SCAN},
//5470 to 5725
{100, eSIR_ACTIVE_SCAN},
{104, eSIR_ACTIVE_SCAN},
{108, eSIR_ACTIVE_SCAN},
{112, eSIR_ACTIVE_SCAN},
{116, eSIR_ACTIVE_SCAN},
{120, eSIR_ACTIVE_SCAN},
{124, eSIR_ACTIVE_SCAN},
{128, eSIR_ACTIVE_SCAN},
{132, eSIR_ACTIVE_SCAN},
{136, eSIR_ACTIVE_SCAN},
{140, eSIR_ACTIVE_SCAN},
//5745 - 5825
{149, eSIR_ACTIVE_SCAN},
{153, eSIR_ACTIVE_SCAN},
{157, eSIR_ACTIVE_SCAN},
{161, eSIR_ACTIVE_SCAN},
{165, eSIR_ACTIVE_SCAN},
//4.9GHz
//4920 - 5080
{240, eSIR_ACTIVE_SCAN},
{244, eSIR_ACTIVE_SCAN},
{248, eSIR_ACTIVE_SCAN},
{252, eSIR_ACTIVE_SCAN},
{208, eSIR_ACTIVE_SCAN},
{212, eSIR_ACTIVE_SCAN},
{216, eSIR_ACTIVE_SCAN},
//2,4GHz
{1, eSIR_ACTIVE_SCAN},
{2, eSIR_ACTIVE_SCAN},
{3, eSIR_ACTIVE_SCAN},
{4, eSIR_ACTIVE_SCAN},
{5, eSIR_ACTIVE_SCAN},
{6, eSIR_ACTIVE_SCAN},
{7, eSIR_ACTIVE_SCAN},
{8, eSIR_ACTIVE_SCAN},
{9, eSIR_ACTIVE_SCAN},
{10, eSIR_ACTIVE_SCAN},
{11, eSIR_ACTIVE_SCAN},
{12, eSIR_ACTIVE_SCAN},
{13, eSIR_ACTIVE_SCAN},
{14, eSIR_ACTIVE_SCAN},
}
},
};
#endif
extern const tRfChannelProps rfChannels[NUM_RF_CHANNELS];
////////////////////////////////////////////////////////////////////////
/**
* \var gPhyRatesSuppt
*
* \brief Rate support lookup table
*
*
* This is a lookup table indexing rates & configuration parameters to
* support. Given a rate (in unites of 0.5Mpbs) & three booleans (MIMO
* Enabled, Channel Bonding Enabled, & Concatenation Enabled), one can
* determine whether the given rate is supported by computing two
* indices. The first maps the rate to table row as indicated below
* (i.e. eHddSuppRate_6Mbps maps to row zero, eHddSuppRate_9Mbps to row
* 1, and so on). Index two can be computed like so:
*
* \code
idx2 = ( fEsf ? 0x4 : 0x0 ) |
( fCb ? 0x2 : 0x0 ) |
( fMimo ? 0x1 : 0x0 );
* \endcode
*
*
* Given that:
*
\code
fSupported = gPhyRatesSuppt[idx1][idx2];
\endcode
*
*
* This table is based on the document "PHY Supported Rates.doc". This
* table is permissive in that a rate is reflected as being supported
* even when turning off an enabled feature would be required. For
* instance, "PHY Supported Rates" lists 42Mpbs as unsupported when CB,
* ESF, & MIMO are all on. However, if we turn off either of CB or
* MIMO, it then becomes supported. Therefore, we mark it as supported
* even in index 7 of this table.
*
*
*/
static const tANI_BOOLEAN gPhyRatesSuppt[24][8] = {
// SSF SSF SSF SSF ESF ESF ESF ESF
// SIMO MIMO SIMO MIMO SIMO MIMO SIMO MIMO
// No CB No CB CB CB No CB No CB CB CB
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 6Mbps
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 9Mbps
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 12Mbps
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 18Mbps
{ FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE }, // 20Mbps
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 24Mbps
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 36Mbps
{ FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 40Mbps
{ FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 42Mbps
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 48Mbps
{ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 54Mbps
{ FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 72Mbps
{ FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 80Mbps
{ FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 84Mbps
{ FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 96Mbps
{ FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 108Mbps
{ FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 120Mbps
{ FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 126Mbps
{ FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 144Mbps
{ FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 160Mbps
{ FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 168Mbps
{ FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 192Mbps
{ FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 216Mbps
{ FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 240Mbps
};
#define CASE_RETURN_STR(n) case (n): return (#n)
const char *
get_eRoamCmdStatus_str(eRoamCmdStatus val)
{
switch (val)
{
CASE_RETURN_STR(eCSR_ROAM_CANCELLED);
CASE_RETURN_STR(eCSR_ROAM_ROAMING_START);
CASE_RETURN_STR(eCSR_ROAM_ROAMING_COMPLETION);
CASE_RETURN_STR(eCSR_ROAM_ASSOCIATION_START);
CASE_RETURN_STR(eCSR_ROAM_ASSOCIATION_COMPLETION);
CASE_RETURN_STR(eCSR_ROAM_DISASSOCIATED);
CASE_RETURN_STR(eCSR_ROAM_SHOULD_ROAM);
CASE_RETURN_STR(eCSR_ROAM_SCAN_FOUND_NEW_BSS);
CASE_RETURN_STR(eCSR_ROAM_LOSTLINK);
default:
return "unknown";
}
}
const char *
get_eCsrRoamResult_str(eCsrRoamResult val)
{
switch (val)
{
CASE_RETURN_STR(eCSR_ROAM_RESULT_NONE);
CASE_RETURN_STR(eCSR_ROAM_RESULT_FAILURE);
CASE_RETURN_STR(eCSR_ROAM_RESULT_ASSOCIATED);
CASE_RETURN_STR(eCSR_ROAM_RESULT_NOT_ASSOCIATED);
CASE_RETURN_STR(eCSR_ROAM_RESULT_MIC_FAILURE);
CASE_RETURN_STR(eCSR_ROAM_RESULT_FORCED);
CASE_RETURN_STR(eCSR_ROAM_RESULT_DISASSOC_IND);
CASE_RETURN_STR(eCSR_ROAM_RESULT_DEAUTH_IND);
CASE_RETURN_STR(eCSR_ROAM_RESULT_CAP_CHANGED);
CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_CONNECT);
CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_INACTIVE);
CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_NEW_PEER);
CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_COALESCED);
default:
return "unknown";
}
}
tANI_BOOLEAN csrGetBssIdBssDesc( tHalHandle hHal, tSirBssDescription *pSirBssDesc, tCsrBssid *pBssId )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
palCopyMemory( pMac->hHdd, pBssId, &pSirBssDesc->bssId[ 0 ], sizeof(tCsrBssid) );
return( TRUE );
}
tANI_BOOLEAN csrIsBssIdEqual( tHalHandle hHal, tSirBssDescription *pSirBssDesc1, tSirBssDescription *pSirBssDesc2 )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fEqual = FALSE;
tCsrBssid bssId1;
tCsrBssid bssId2;
do {
if ( !pSirBssDesc1 ) break;
if ( !pSirBssDesc2 ) break;
if ( !csrGetBssIdBssDesc( pMac, pSirBssDesc1, &bssId1 ) ) break;
if ( !csrGetBssIdBssDesc( pMac, pSirBssDesc2, &bssId2 ) ) break;
//sirCompareMacAddr
fEqual = csrIsMacAddressEqual(pMac, &bssId1, &bssId2);
} while( 0 );
return( fEqual );
}
tANI_BOOLEAN csrIsConnStateConnectedIbss( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( eCSR_ASSOC_STATE_TYPE_IBSS_CONNECTED == pMac->roam.roamSession[sessionId].connectState );
}
tANI_BOOLEAN csrIsConnStateDisconnectedIbss( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( eCSR_ASSOC_STATE_TYPE_IBSS_DISCONNECTED == pMac->roam.roamSession[sessionId].connectState );
}
tANI_BOOLEAN csrIsConnStateConnectedInfra( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( eCSR_ASSOC_STATE_TYPE_INFRA_ASSOCIATED == pMac->roam.roamSession[sessionId].connectState );
}
tANI_BOOLEAN csrIsConnStateConnected( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
if( csrIsConnStateConnectedIbss( pMac, sessionId ) || csrIsConnStateConnectedInfra( pMac, sessionId ) || csrIsConnStateConnectedWds( pMac, sessionId) )
return TRUE;
else
return FALSE;
}
tANI_BOOLEAN csrIsConnStateInfra( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( csrIsConnStateConnectedInfra( pMac, sessionId ) );
}
tANI_BOOLEAN csrIsConnStateIbss( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( csrIsConnStateConnectedIbss( pMac, sessionId ) || csrIsConnStateDisconnectedIbss( pMac, sessionId ) );
}
tANI_BOOLEAN csrIsConnStateConnectedWds( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( eCSR_ASSOC_STATE_TYPE_WDS_CONNECTED == pMac->roam.roamSession[sessionId].connectState );
}
tANI_BOOLEAN csrIsConnStateConnectedInfraAp( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( (eCSR_ASSOC_STATE_TYPE_INFRA_CONNECTED == pMac->roam.roamSession[sessionId].connectState) ||
(eCSR_ASSOC_STATE_TYPE_INFRA_DISCONNECTED == pMac->roam.roamSession[sessionId].connectState ) );
}
tANI_BOOLEAN csrIsConnStateDisconnectedWds( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( eCSR_ASSOC_STATE_TYPE_WDS_DISCONNECTED == pMac->roam.roamSession[sessionId].connectState );
}
tANI_BOOLEAN csrIsConnStateWds( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return( csrIsConnStateConnectedWds( pMac, sessionId ) ||
csrIsConnStateDisconnectedWds( pMac, sessionId ) );
}
tANI_BOOLEAN csrIsConnStateAp( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
tCsrRoamSession *pSession;
pSession = CSR_GET_SESSION(pMac, sessionId);
if (!pSession)
return eANI_BOOLEAN_FALSE;
if ( CSR_IS_INFRA_AP(&pSession->connectedProfile) )
{
return eANI_BOOLEAN_TRUE;
}
return eANI_BOOLEAN_FALSE;
}
tANI_BOOLEAN csrIsAnySessionInConnectState( tpAniSirGlobal pMac )
{
tANI_U32 i;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) &&
( csrIsConnStateInfra( pMac, i )
|| csrIsConnStateIbss( pMac, i )
|| csrIsConnStateAp( pMac, i) ) )
{
fRc = eANI_BOOLEAN_TRUE;
break;
}
}
return ( fRc );
}
tANI_S8 csrGetInfraSessionId( tpAniSirGlobal pMac )
{
tANI_U8 i;
tANI_S8 sessionid = -1;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateInfra( pMac, i ) )
{
sessionid = i;
break;
}
}
return ( sessionid );
}
tANI_U8 csrGetInfraOperationChannel( tpAniSirGlobal pMac, tANI_U8 sessionId)
{
tANI_U8 channel;
if( CSR_IS_SESSION_VALID( pMac, sessionId ))
{
channel = pMac->roam.roamSession[sessionId].connectedProfile.operationChannel;
}
else
{
channel = 0;
}
return channel;
}
//This routine will return operating channel on FIRST BSS that is active/operating to be used for concurrency mode.
//If other BSS is not up or not connected it will return 0
tANI_U8 csrGetConcurrentOperationChannel( tpAniSirGlobal pMac )
{
tCsrRoamSession *pSession = NULL;
tANI_U8 i = 0;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) )
{
pSession = CSR_GET_SESSION( pMac, i );
if (NULL != pSession->pCurRoamProfile)
{
if (
(((pSession->pCurRoamProfile->csrPersona == VOS_STA_MODE) ||
(pSession->pCurRoamProfile->csrPersona == VOS_P2P_CLIENT_MODE)) &&
(pSession->connectState == eCSR_ASSOC_STATE_TYPE_INFRA_ASSOCIATED))
||
(((pSession->pCurRoamProfile->csrPersona == VOS_P2P_GO_MODE) ||
(pSession->pCurRoamProfile->csrPersona == VOS_STA_SAP_MODE)) &&
(pSession->connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
)
return (pSession->connectedProfile.operationChannel);
}
}
}
return 0;
}
tANI_BOOLEAN csrIsAllSessionDisconnected( tpAniSirGlobal pMac )
{
tANI_U32 i;
tANI_BOOLEAN fRc = eANI_BOOLEAN_TRUE;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
{
fRc = eANI_BOOLEAN_FALSE;
break;
}
}
return ( fRc );
}
tANI_BOOLEAN csrIsStaSessionConnected( tpAniSirGlobal pMac )
{
tANI_U32 i;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
tCsrRoamSession *pSession = NULL;
tANI_U32 countSta = 0;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
{
pSession = CSR_GET_SESSION( pMac, i );
if (NULL != pSession->pCurRoamProfile)
{
if (pSession->pCurRoamProfile->csrPersona == VOS_STA_MODE) {
countSta++;
}
}
}
}
/* return TRUE if one of the following conditions is TRUE:
* - more than one STA session connected
*/
if ( countSta > 0) {
fRc = eANI_BOOLEAN_TRUE;
}
return( fRc );
}
tANI_BOOLEAN csrIsP2pSessionConnected( tpAniSirGlobal pMac )
{
tANI_U32 i;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
tCsrRoamSession *pSession = NULL;
tANI_U32 countP2pCli = 0;
tANI_U32 countP2pGo = 0;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
{
pSession = CSR_GET_SESSION( pMac, i );
if (NULL != pSession->pCurRoamProfile)
{
if (pSession->pCurRoamProfile->csrPersona == VOS_P2P_CLIENT_MODE) {
countP2pCli++;
}
if (pSession->pCurRoamProfile->csrPersona == VOS_P2P_GO_MODE) {
countP2pGo++;
}
}
}
}
/* return TRUE if one of the following conditions is TRUE:
* - at least one P2P CLI session is connected
* - at least one P2P GO session is connected
*/
if ( (countP2pCli > 0) || (countP2pGo > 0 ) ) {
fRc = eANI_BOOLEAN_TRUE;
}
return( fRc );
}
tANI_BOOLEAN csrIsAnySessionConnected( tpAniSirGlobal pMac )
{
tANI_U32 i, count;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
count = 0;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
{
count++;
}
}
if (count > 0)
{
fRc = eANI_BOOLEAN_TRUE;
}
return( fRc );
}
tANI_BOOLEAN csrIsInfraConnected( tpAniSirGlobal pMac )
{
tANI_U32 i;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedInfra( pMac, i ) )
{
fRc = eANI_BOOLEAN_TRUE;
break;
}
}
return ( fRc );
}
tANI_BOOLEAN csrIsConcurrentInfraConnected( tpAniSirGlobal pMac )
{
tANI_U32 i, noOfConnectedInfra = 0;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedInfra( pMac, i ) )
{
++noOfConnectedInfra;
}
}
// More than one Infra Sta Connected
if(noOfConnectedInfra > 1)
{
fRc = eANI_BOOLEAN_TRUE;
}
return ( fRc );
}
tANI_BOOLEAN csrIsIBSSStarted( tpAniSirGlobal pMac )
{
tANI_U32 i;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateIbss( pMac, i ) )
{
fRc = eANI_BOOLEAN_TRUE;
break;
}
}
return ( fRc );
}
tANI_BOOLEAN csrIsBTAMPStarted( tpAniSirGlobal pMac )
{
tANI_U32 i;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
{
if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedWds( pMac, i ) )
{
fRc = eANI_BOOLEAN_TRUE;
break;
}
}
return ( fRc );
}
tANI_BOOLEAN csrIsConcurrentSessionRunning( tpAniSirGlobal pMac )
{
tANI_U32 sessionId, noOfCocurrentSession = 0;
eCsrConnectState connectState;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
for( sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
{
if( CSR_IS_SESSION_VALID( pMac, sessionId ) )
{
connectState = pMac->roam.roamSession[sessionId].connectState;
if( (eCSR_ASSOC_STATE_TYPE_INFRA_ASSOCIATED == connectState) ||
(eCSR_ASSOC_STATE_TYPE_INFRA_CONNECTED == connectState) ||
(eCSR_ASSOC_STATE_TYPE_INFRA_DISCONNECTED == connectState) )
{
++noOfCocurrentSession;
}
}
}
// More than one session is Up and Running
if(noOfCocurrentSession > 1)
{
fRc = eANI_BOOLEAN_TRUE;
}
return ( fRc );
}
tANI_BOOLEAN csrIsInfraApStarted( tpAniSirGlobal pMac )
{
tANI_U32 sessionId;
tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
for( sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
{
if( CSR_IS_SESSION_VALID( pMac, sessionId ) && (csrIsConnStateConnectedInfraAp(pMac, sessionId)) )
{
fRc = eANI_BOOLEAN_TRUE;
break;
}
}
return ( fRc );
}
tANI_BOOLEAN csrIsBTAMP( tpAniSirGlobal pMac, tANI_U32 sessionId )
{
return ( csrIsConnStateConnectedWds( pMac, sessionId ) );
}
tANI_BOOLEAN csrIsConnStateDisconnected(tpAniSirGlobal pMac, tANI_U32 sessionId)
{
return (eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED == pMac->roam.roamSession[sessionId].connectState);
}
tANI_BOOLEAN csrIsValidMcConcurrentSession(tpAniSirGlobal pMac, tANI_U32 sessionId,
tSirBssDescription *pBssDesc)
{
tCsrRoamSession *pSession = NULL;
eAniBoolean status = eANI_BOOLEAN_FALSE;
//Check for MCC support
if (!pMac->roam.configParam.fenableMCCMode)
{
return status;
}
//Validate BeaconInterval
if( CSR_IS_SESSION_VALID( pMac, sessionId ) )
{
pSession = CSR_GET_SESSION( pMac, sessionId );
if (NULL != pSession->pCurRoamProfile)
{
if (csrIsconcurrentsessionValid (pMac, sessionId,
pSession->pCurRoamProfile->csrPersona)
== eHAL_STATUS_SUCCESS )
{
if (csrValidateMCCBeaconInterval( pMac, pBssDesc->channelId,
&pBssDesc->beaconInterval, sessionId,
pSession->pCurRoamProfile->csrPersona)
!= eHAL_STATUS_SUCCESS)
{
status = eANI_BOOLEAN_FALSE;
}
else
{
status = eANI_BOOLEAN_TRUE;
}
}
else
{
status = eANI_BOOLEAN_FALSE;
}
}
}
return status;
}
static tSirMacCapabilityInfo csrGetBssCapabilities( tSirBssDescription *pSirBssDesc )
{
tSirMacCapabilityInfo dot11Caps;
//tSirMacCapabilityInfo is 16-bit
pal_get_U16( (tANI_U8 *)&pSirBssDesc->capabilityInfo, (tANI_U16 *)&dot11Caps );
return( dot11Caps );
}
tANI_BOOLEAN csrIsInfraBssDesc( tSirBssDescription *pSirBssDesc )
{
tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
return( (tANI_BOOLEAN)dot11Caps.ess );
}
tANI_BOOLEAN csrIsIbssBssDesc( tSirBssDescription *pSirBssDesc )
{
tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
return( (tANI_BOOLEAN)dot11Caps.ibss );
}
tANI_BOOLEAN csrIsQoSBssDesc( tSirBssDescription *pSirBssDesc )
{
tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
return( (tANI_BOOLEAN)dot11Caps.qos );
}
tANI_BOOLEAN csrIsPrivacy( tSirBssDescription *pSirBssDesc )
{
tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
return( (tANI_BOOLEAN)dot11Caps.privacy );
}
tANI_BOOLEAN csrIs11dSupported(tpAniSirGlobal pMac)
{
return(pMac->roam.configParam.Is11dSupportEnabled);
}
tANI_BOOLEAN csrIs11hSupported(tpAniSirGlobal pMac)
{
return(pMac->roam.configParam.Is11hSupportEnabled);
}
tANI_BOOLEAN csrIs11eSupported(tpAniSirGlobal pMac)
{
return(pMac->roam.configParam.Is11eSupportEnabled);
}
tANI_BOOLEAN csrIsMCCSupported ( tpAniSirGlobal pMac )
{
return(pMac->roam.configParam.fenableMCCMode);
}
tANI_BOOLEAN csrIsWmmSupported(tpAniSirGlobal pMac)
{
if(eCsrRoamWmmNoQos == pMac->roam.configParam.WMMSupportMode)
{
return eANI_BOOLEAN_FALSE;
}
else
{
return eANI_BOOLEAN_TRUE;
}
}
//pIes is the IEs for pSirBssDesc2
tANI_BOOLEAN csrIsSsidEqual( tHalHandle hHal, tSirBssDescription *pSirBssDesc1,
tSirBssDescription *pSirBssDesc2, tDot11fBeaconIEs *pIes2 )
{
tANI_BOOLEAN fEqual = FALSE;
tSirMacSSid Ssid1, Ssid2;
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tDot11fBeaconIEs *pIes1 = NULL;
tDot11fBeaconIEs *pIesLocal = pIes2;
do {
if( ( NULL == pSirBssDesc1 ) || ( NULL == pSirBssDesc2 ) ) break;
if( !pIesLocal && !HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc2, &pIesLocal)) )
{
smsLog(pMac, LOGE, FL(" fail to parse IEs"));
break;
}
if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc1, &pIes1)))
{
break;
}
if( ( !pIes1->SSID.present ) || ( !pIesLocal->SSID.present ) ) break;
if ( pIes1->SSID.num_ssid != pIesLocal->SSID.num_ssid ) break;
palCopyMemory(pMac->hHdd, Ssid1.ssId, pIes1->SSID.ssid, pIes1->SSID.num_ssid);
palCopyMemory(pMac->hHdd, Ssid2.ssId, pIesLocal->SSID.ssid, pIesLocal->SSID.num_ssid);
fEqual = palEqualMemory(pMac->hHdd, Ssid1.ssId, Ssid2.ssId, pIesLocal->SSID.num_ssid );
} while( 0 );
if(pIes1)
{
palFreeMemory(pMac->hHdd, pIes1);
}
if( pIesLocal && !pIes2 )
{
palFreeMemory(pMac->hHdd, pIesLocal);
}
return( fEqual );
}
tANI_BOOLEAN csrIsAniWmeSupported(tDot11fIEAirgo *pIeAirgo)
{
tANI_BOOLEAN fRet = eANI_BOOLEAN_FALSE;
if(pIeAirgo && pIeAirgo->present && pIeAirgo->PropCapability.present)
{
fRet = (tANI_BOOLEAN)(PROP_CAPABILITY_GET( WME, pIeAirgo->PropCapability.capability ));
}
return fRet;
}
//pIes can be passed in as NULL if the caller doesn't have one prepared
tANI_BOOLEAN csrIsBssDescriptionWme( tHalHandle hHal, tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
// Assume that WME is found...
tANI_BOOLEAN fWme = TRUE;
tDot11fBeaconIEs *pIesTemp = pIes;
do
{
if(pIesTemp == NULL)
{
if( !HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesTemp)) )
{
fWme = FALSE;
break;
}
}
// if the AirgoProprietary indicator is found, then WME is supported...
if ( csrIsAniWmeSupported(&pIesTemp->Airgo) ) break;
// if the Wme Info IE is found, then WME is supported...
if ( CSR_IS_QOS_BSS(pIesTemp) ) break;
// if none of these are found, then WME is NOT supported...
fWme = FALSE;
} while( 0 );
if( !csrIsWmmSupported( pMac ) && fWme)
{
if( !pIesTemp->HTCaps.present )
{
fWme = FALSE;
}
}
if( ( pIes == NULL ) && ( NULL != pIesTemp ) )
{
//we allocate memory here so free it before returning
palFreeMemory(pMac->hHdd, pIesTemp);
}
return( fWme );
}
tANI_BOOLEAN csrIsHcfEnabled( tDot11fIEAirgo *pIeAirgo )
{
tANI_BOOLEAN fHcfSupported = FALSE;
fHcfSupported = ((tANI_BOOLEAN)(PROP_CAPABILITY_GET( WME, pIeAirgo->PropCapability.capability )) ||
(pIeAirgo->present && pIeAirgo->HCF.present && pIeAirgo->HCF.enabled));
return( fHcfSupported );
}
eCsrMediaAccessType csrGetQoSFromBssDesc( tHalHandle hHal, tSirBssDescription *pSirBssDesc,
tDot11fBeaconIEs *pIes )
{
eCsrMediaAccessType qosType = eCSR_MEDIUM_ACCESS_DCF;
VOS_ASSERT( pIes != NULL );
do
{
// if we find WMM in the Bss Description, then we let this
// override and use WMM.
if ( csrIsBssDescriptionWme( hHal, pSirBssDesc, pIes ) )
{
qosType = eCSR_MEDIUM_ACCESS_WMM_eDCF_DSCP;
}
else
{
// if the QoS bit is on, then the AP is advertising 11E QoS...
if ( csrIsQoSBssDesc( pSirBssDesc ) )
{
// which could be HCF or eDCF.
if ( csrIsHcfEnabled( &pIes->Airgo ) )
{
qosType = eCSR_MEDIUM_ACCESS_11e_HCF;
}
else
{
qosType = eCSR_MEDIUM_ACCESS_11e_eDCF;
}
}
else
{
qosType = eCSR_MEDIUM_ACCESS_DCF;
}
// scale back based on the types turned on for the adapter...
if ( eCSR_MEDIUM_ACCESS_11e_eDCF == qosType && !csrIs11eSupported( hHal ) )
{
qosType = eCSR_MEDIUM_ACCESS_DCF;
}
}
} while(0);
return( qosType );
}
//Caller allocates memory for pIEStruct
eHalStatus csrParseBssDescriptionIEs(tHalHandle hHal, tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIEStruct)
{
eHalStatus status = eHAL_STATUS_FAILURE;
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
int ieLen = (int)(pBssDesc->length + sizeof( pBssDesc->length ) - GET_FIELD_OFFSET( tSirBssDescription, ieFields ));
if(ieLen > 0 && pIEStruct)
{
if(!DOT11F_FAILED(dot11fUnpackBeaconIEs( pMac, (tANI_U8 *)pBssDesc->ieFields, ieLen, pIEStruct )))
{
status = eHAL_STATUS_SUCCESS;
}
}
return (status);
}
//This function will allocate memory for the parsed IEs to the caller. Caller must free the memory
//after it is done with the data only if this function succeeds
eHalStatus csrGetParsedBssDescriptionIEs(tHalHandle hHal, tSirBssDescription *pBssDesc, tDot11fBeaconIEs **ppIEStruct)
{
eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
if(pBssDesc && ppIEStruct)
{
status = palAllocateMemory(pMac->hHdd, (void **)ppIEStruct, sizeof(tDot11fBeaconIEs));
if(HAL_STATUS_SUCCESS(status))
{
palZeroMemory(pMac->hHdd, (void *)*ppIEStruct, sizeof(tDot11fBeaconIEs));
status = csrParseBssDescriptionIEs(hHal, pBssDesc, *ppIEStruct);
if(!HAL_STATUS_SUCCESS(status))
{
palFreeMemory(pMac->hHdd, *ppIEStruct);
*ppIEStruct = NULL;
}
}
else
{
smsLog( pMac, LOGE, FL(" failed to allocate memory") );
VOS_ASSERT( 0 );
}
}
return (status);
}
tANI_BOOLEAN csrIsNULLSSID( tANI_U8 *pBssSsid, tANI_U8 len )
{
tANI_BOOLEAN fNullSsid = FALSE;
tANI_U32 SsidLength;
tANI_U8 *pSsidStr;
do
{
if ( 0 == len )
{
fNullSsid = TRUE;
break;
}
//Consider 0 or space for hidden SSID
if ( 0 == pBssSsid[0] )
{
fNullSsid = TRUE;
break;
}
SsidLength = len;
pSsidStr = pBssSsid;
while ( SsidLength )
{
if( *pSsidStr )
break;
pSsidStr++;
SsidLength--;
}
if( 0 == SsidLength )
{
fNullSsid = TRUE;
break;
}
}
while( 0 );
return fNullSsid;
}
tANI_U32 csrGetFragThresh( tHalHandle hHal )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
return pMac->roam.configParam.FragmentationThreshold;
}
tANI_U32 csrGetRTSThresh( tHalHandle hHal )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
return pMac->roam.configParam.RTSThreshold;
}
eCsrPhyMode csrTranslateToPhyModeFromBssDesc( tSirBssDescription *pSirBssDesc )
{
eCsrPhyMode phyMode;
switch ( pSirBssDesc->nwType )
{
case eSIR_11A_NW_TYPE:
phyMode = eCSR_DOT11_MODE_11a;
break;
case eSIR_11B_NW_TYPE:
phyMode = eCSR_DOT11_MODE_11b;
break;
case eSIR_11G_NW_TYPE:
phyMode = eCSR_DOT11_MODE_11g;
break;
case eSIR_11N_NW_TYPE:
phyMode = eCSR_DOT11_MODE_11n;
break;
#ifdef WLAN_FEATURE_11AC
case eSIR_11AC_NW_TYPE:
default:
phyMode = eCSR_DOT11_MODE_11ac;
#else
default:
phyMode = eCSR_DOT11_MODE_11n;
#endif
break;
}
return( phyMode );
}
tANI_U32 csrTranslateToWNICfgDot11Mode(tpAniSirGlobal pMac, eCsrCfgDot11Mode csrDot11Mode)
{
tANI_U32 ret;
switch(csrDot11Mode)
{
case eCSR_CFG_DOT11_MODE_AUTO:
smsLog(pMac, LOGW, FL(" Warning: sees eCSR_CFG_DOT11_MODE_AUTO "));
//We cannot decide until now.
if(pMac->roam.configParam.ProprietaryRatesEnabled)
{
ret = WNI_CFG_DOT11_MODE_TAURUS;
}
else
{
ret = WNI_CFG_DOT11_MODE_11AC;
}
break;
case eCSR_CFG_DOT11_MODE_TAURUS:
ret = WNI_CFG_DOT11_MODE_TAURUS;
break;
case eCSR_CFG_DOT11_MODE_11A:
ret = WNI_CFG_DOT11_MODE_11A;
break;
case eCSR_CFG_DOT11_MODE_11B:
ret = WNI_CFG_DOT11_MODE_11B;
break;
case eCSR_CFG_DOT11_MODE_11G:
ret = WNI_CFG_DOT11_MODE_11G;
break;
case eCSR_CFG_DOT11_MODE_11N:
ret = WNI_CFG_DOT11_MODE_11N;
break;
case eCSR_CFG_DOT11_MODE_POLARIS:
ret = WNI_CFG_DOT11_MODE_POLARIS;
break;
case eCSR_CFG_DOT11_MODE_TITAN:
ret = WNI_CFG_DOT11_MODE_TITAN;
break;
case eCSR_CFG_DOT11_MODE_11G_ONLY:
ret = WNI_CFG_DOT11_MODE_11G_ONLY;
break;
case eCSR_CFG_DOT11_MODE_11N_ONLY:
ret = WNI_CFG_DOT11_MODE_11N_ONLY;
break;
#ifdef WLAN_FEATURE_11AC
case eCSR_CFG_DOT11_MODE_11AC_ONLY:
ret = WNI_CFG_DOT11_MODE_11AC_ONLY;
break;
case eCSR_CFG_DOT11_MODE_11AC:
ret = WNI_CFG_DOT11_MODE_11AC;
break;
#endif
default:
smsLog(pMac, LOGW, FL("doesn't expect %d as csrDo11Mode"), csrDot11Mode);
if(eCSR_BAND_24 == pMac->roam.configParam.eBand)
{
ret = WNI_CFG_DOT11_MODE_11G;
}
else
{
ret = WNI_CFG_DOT11_MODE_11A;
}
break;
}
return (ret);
}
//This function should only return the super set of supported modes. 11n implies 11b/g/a/n.
eHalStatus csrGetPhyModeFromBss(tpAniSirGlobal pMac, tSirBssDescription *pBSSDescription,
eCsrPhyMode *pPhyMode, tDot11fBeaconIEs *pIes)
{
eHalStatus status = eHAL_STATUS_SUCCESS;
eCsrPhyMode phyMode = csrTranslateToPhyModeFromBssDesc(pBSSDescription);
if( pIes )
{
if(pIes->Airgo.present)
{
if(pIes->Airgo.PropCapability.present)
{
if( PROP_CAPABILITY_GET( TAURUS, pIes->Airgo.PropCapability.capability ))
{
phyMode = eCSR_DOT11_MODE_TAURUS;
}
}
}
if(pIes->HTCaps.present && (eCSR_DOT11_MODE_TAURUS != phyMode))
{
phyMode = eCSR_DOT11_MODE_11n;
}
#ifdef WLAN_FEATURE_11AC
if ( pIes->VHTCaps.present && (eCSR_DOT11_MODE_TAURUS != phyMode))
{
phyMode = eCSR_DOT11_MODE_11ac;
}
#endif
*pPhyMode = phyMode;
}
return (status);
}
//This function returns the correct eCSR_CFG_DOT11_MODE is the two phyModes matches
//bssPhyMode is the mode derived from the BSS description
//f5GhzBand is derived from the channel id of BSS description
tANI_BOOLEAN csrGetPhyModeInUse( eCsrPhyMode phyModeIn, eCsrPhyMode bssPhyMode, tANI_BOOLEAN f5GhzBand,
eCsrCfgDot11Mode *pCfgDot11ModeToUse )
{
tANI_BOOLEAN fMatch = FALSE;
eCsrCfgDot11Mode cfgDot11Mode;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; // to suppress compiler warning
switch( phyModeIn )
{
case eCSR_DOT11_MODE_abg: //11a or 11b or 11g
if( f5GhzBand )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
}
else if( eCSR_DOT11_MODE_11b == bssPhyMode )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
}
else
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
}
break;
case eCSR_DOT11_MODE_11a: //11a
if( f5GhzBand )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
}
break;
case eCSR_DOT11_MODE_11a_ONLY: //11a
if( eCSR_DOT11_MODE_11a == bssPhyMode )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
}
break;
case eCSR_DOT11_MODE_11g:
if(!f5GhzBand)
{
if( eCSR_DOT11_MODE_11b == bssPhyMode )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
}
else
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
}
}
break;
case eCSR_DOT11_MODE_11g_ONLY:
if( eCSR_DOT11_MODE_11g == bssPhyMode )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
}
break;
case eCSR_DOT11_MODE_11b:
if( !f5GhzBand )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
}
break;
case eCSR_DOT11_MODE_11b_ONLY:
if( eCSR_DOT11_MODE_11b == bssPhyMode )
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
}
break;
case eCSR_DOT11_MODE_11n:
fMatch = TRUE;
switch(bssPhyMode)
{
case eCSR_DOT11_MODE_11g:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
break;
case eCSR_DOT11_MODE_11b:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
break;
case eCSR_DOT11_MODE_11a:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
break;
case eCSR_DOT11_MODE_11n:
#ifdef WLAN_FEATURE_11AC
case eCSR_DOT11_MODE_11ac:
#endif
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
break;
case eCSR_DOT11_MODE_TAURUS:
default:
#ifdef WLAN_FEATURE_11AC
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
#else
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
#endif
break;
}
break;
case eCSR_DOT11_MODE_11n_ONLY:
if((eCSR_DOT11_MODE_11n == bssPhyMode) || (eCSR_DOT11_MODE_TAURUS == bssPhyMode))
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
}
break;
#ifdef WLAN_FEATURE_11AC
case eCSR_DOT11_MODE_11ac:
fMatch = TRUE;
switch(bssPhyMode)
{
case eCSR_DOT11_MODE_11g:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
break;
case eCSR_DOT11_MODE_11b:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
break;
case eCSR_DOT11_MODE_11a:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
break;
case eCSR_DOT11_MODE_11n:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
break;
case eCSR_DOT11_MODE_11ac:
case eCSR_DOT11_MODE_TAURUS:
default:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
break;
}
break;
case eCSR_DOT11_MODE_11ac_ONLY:
if((eCSR_DOT11_MODE_11ac == bssPhyMode) || (eCSR_DOT11_MODE_TAURUS == bssPhyMode))
{
fMatch = TRUE;
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
}
break;
#endif
case eCSR_DOT11_MODE_TAURUS:
default:
fMatch = TRUE;
switch(bssPhyMode)
{
case eCSR_DOT11_MODE_11g:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
break;
case eCSR_DOT11_MODE_11b:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
break;
case eCSR_DOT11_MODE_11a:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
break;
case eCSR_DOT11_MODE_11n:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
break;
#ifdef WLAN_FEATURE_11AC
case eCSR_DOT11_MODE_11ac:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
break;
#endif
case eCSR_DOT11_MODE_TAURUS:
default:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
break;
}
break;
}
if ( fMatch && pCfgDot11ModeToUse )
{
#ifdef WLAN_FEATURE_11AC
if(cfgDot11Mode == eCSR_CFG_DOT11_MODE_11AC && (!IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)))
{
*pCfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
}
else
#endif
{
*pCfgDot11ModeToUse = cfgDot11Mode;
}
}
return( fMatch );
}
//This function decides whether the one of the bit of phyMode is matching the mode in the BSS and allowed by the user
//setting, pMac->roam.configParam.uCfgDot11Mode. It returns the mode that fits the criteria.
tANI_BOOLEAN csrIsPhyModeMatch( tpAniSirGlobal pMac, tANI_U32 phyMode,
tSirBssDescription *pSirBssDesc, tCsrRoamProfile *pProfile,
eCsrCfgDot11Mode *pReturnCfgDot11Mode,
tDot11fBeaconIEs *pIes)
{
tANI_BOOLEAN fMatch = FALSE;
eCsrPhyMode phyModeInBssDesc, phyMode2;
eCsrCfgDot11Mode cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_TAURUS;
tANI_U32 bitMask, loopCount;
if(HAL_STATUS_SUCCESS(csrGetPhyModeFromBss(pMac, pSirBssDesc, &phyModeInBssDesc, pIes )))
{
//In case some change change eCSR_DOT11_MODE_TAURUS to non-0
if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode))
{
//Taurus means anything
if ( eCSR_CFG_DOT11_MODE_ABG == pMac->roam.configParam.uCfgDot11Mode )
{
phyMode = eCSR_DOT11_MODE_abg;
}
else if(eCSR_CFG_DOT11_MODE_AUTO == pMac->roam.configParam.uCfgDot11Mode)
{
if(pMac->roam.configParam.ProprietaryRatesEnabled)
{
phyMode = eCSR_DOT11_MODE_TAURUS;
}
else
{
#ifdef WLAN_FEATURE_11AC
phyMode = eCSR_DOT11_MODE_11ac;
#else
phyMode = eCSR_DOT11_MODE_11n;
#endif
}
}
else
{
//user's pick
phyMode = pMac->roam.configParam.phyMode;
}
}
if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode) )
{
if(0 != phyMode)
{
if(eCSR_DOT11_MODE_AUTO & phyMode)
{
phyMode2 = eCSR_DOT11_MODE_AUTO & phyMode;
}
else
{
phyMode2 = eCSR_DOT11_MODE_TAURUS & phyMode;
}
}
else
{
phyMode2 = phyMode;
}
fMatch = csrGetPhyModeInUse( phyMode2, phyModeInBssDesc, CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId),
&cfgDot11ModeToUse );
}
else
{
bitMask = 1;
loopCount = 0;
while(loopCount < eCSR_NUM_PHY_MODE)
{
if(0 != ( phyMode2 = (phyMode & (bitMask << loopCount++)) ))
{
fMatch = csrGetPhyModeInUse( phyMode2, phyModeInBssDesc, CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId),
&cfgDot11ModeToUse );
if(fMatch) break;
}
}
}
if ( fMatch && pReturnCfgDot11Mode )
{
if( pProfile )
{
/* IEEE 11n spec (8.4.3): HT STA shall eliminate TKIP as a
* choice for the pairwise cipher suite if CCMP is advertised
* by the AP or if the AP included an HT capabilities element
* in its Beacons and Probe Response.
*/
if( (!CSR_IS_11n_ALLOWED( pProfile->negotiatedUCEncryptionType )) &&
((eCSR_CFG_DOT11_MODE_11N == cfgDot11ModeToUse) ||
#ifdef WLAN_FEATURE_11AC
(eCSR_CFG_DOT11_MODE_11AC == cfgDot11ModeToUse) ||
#endif
(eCSR_CFG_DOT11_MODE_TAURUS == cfgDot11ModeToUse)) )
{
//We cannot do 11n here
if( !CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId) )
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
}
else
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
}
}
}
*pReturnCfgDot11Mode = cfgDot11ModeToUse;
}
}
return( fMatch );
}
eCsrCfgDot11Mode csrFindBestPhyMode( tpAniSirGlobal pMac, tANI_U32 phyMode )
{
eCsrCfgDot11Mode cfgDot11ModeToUse;
eCsrBand eBand = pMac->roam.configParam.eBand;
#ifdef WLAN_FEATURE_11AC
if ((0 == phyMode) || ((eCSR_DOT11_MODE_AUTO & phyMode) && (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)))
|| ((eCSR_DOT11_MODE_11ac & phyMode) && (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC))))
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11AC;
}
else
#endif
if ((0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode))
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
}
else
{
if( ( eCSR_DOT11_MODE_11n | eCSR_DOT11_MODE_11n_ONLY ) & phyMode )
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
}
else if ( eCSR_DOT11_MODE_abg & phyMode )
{
if( eCSR_BAND_24 != eBand )
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
}
else
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
}
}
else if( ( eCSR_DOT11_MODE_11a | eCSR_DOT11_MODE_11a_ONLY ) & phyMode )
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
}
else if( ( eCSR_DOT11_MODE_11g | eCSR_DOT11_MODE_11g_ONLY ) & phyMode )
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
}
else
{
cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11B;
}
}
return ( cfgDot11ModeToUse );
}
tANI_U32 csrGet11hPowerConstraint( tHalHandle hHal, tDot11fIEPowerConstraints *pPowerConstraint )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_U32 localPowerConstraint = 0;
// check if .11h support is enabled, if not, the power constraint is 0.
if(pMac->roam.configParam.Is11hSupportEnabled && pPowerConstraint->present)
{
localPowerConstraint = pPowerConstraint->localPowerConstraints;
}
return( localPowerConstraint );
}
tANI_BOOLEAN csrIsProfileWpa( tCsrRoamProfile *pProfile )
{
tANI_BOOLEAN fWpaProfile = FALSE;
switch ( pProfile->negotiatedAuthType )
{
case eCSR_AUTH_TYPE_WPA:
case eCSR_AUTH_TYPE_WPA_PSK:
case eCSR_AUTH_TYPE_WPA_NONE:
#ifdef FEATURE_WLAN_CCX
case eCSR_AUTH_TYPE_CCKM_WPA:
#endif
fWpaProfile = TRUE;
break;
default:
fWpaProfile = FALSE;
break;
}
if ( fWpaProfile )
{
switch ( pProfile->negotiatedUCEncryptionType )
{
case eCSR_ENCRYPT_TYPE_WEP40:
case eCSR_ENCRYPT_TYPE_WEP104:
case eCSR_ENCRYPT_TYPE_TKIP:
case eCSR_ENCRYPT_TYPE_AES:
fWpaProfile = TRUE;
break;
default:
fWpaProfile = FALSE;
break;
}
}
return( fWpaProfile );
}
tANI_BOOLEAN csrIsProfileRSN( tCsrRoamProfile *pProfile )
{
tANI_BOOLEAN fRSNProfile = FALSE;
switch ( pProfile->negotiatedAuthType )
{
case eCSR_AUTH_TYPE_RSN:
case eCSR_AUTH_TYPE_RSN_PSK:
#ifdef WLAN_FEATURE_VOWIFI_11R
case eCSR_AUTH_TYPE_FT_RSN:
case eCSR_AUTH_TYPE_FT_RSN_PSK:
#endif
#ifdef FEATURE_WLAN_CCX
case eCSR_AUTH_TYPE_CCKM_RSN:
#endif
#ifdef WLAN_FEATURE_11W
case eCSR_AUTH_TYPE_RSN_PSK_SHA256:
#endif
fRSNProfile = TRUE;
break;
default:
fRSNProfile = FALSE;
break;
}
if ( fRSNProfile )
{
switch ( pProfile->negotiatedUCEncryptionType )
{
// !!REVIEW - For WPA2, use of RSN IE mandates
// use of AES as encryption. Here, we qualify
// even if encryption type is WEP or TKIP
case eCSR_ENCRYPT_TYPE_WEP40:
case eCSR_ENCRYPT_TYPE_WEP104:
case eCSR_ENCRYPT_TYPE_TKIP:
case eCSR_ENCRYPT_TYPE_AES:
fRSNProfile = TRUE;
break;
default:
fRSNProfile = FALSE;
break;
}
}
return( fRSNProfile );
}
eHalStatus
csrIsconcurrentsessionValid(tpAniSirGlobal pMac,tANI_U32 cursessionId,
tVOS_CON_MODE currBssPersona)
{
tANI_U32 sessionId = 0;
for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
{
if (cursessionId != sessionId )
{
if (!CSR_IS_SESSION_VALID( pMac, sessionId ))
{
continue;
}
switch (currBssPersona)
{
case VOS_STA_MODE:
if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
(pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
== VOS_STA_MODE)) //check for P2P client mode
{
smsLog(pMac, LOGE, FL(" ****STA mode already exists ****"));
return eHAL_STATUS_FAILURE;
}
break;
case VOS_STA_SAP_MODE:
if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_STA_SAP_MODE)&&
(pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
{
smsLog(pMac, LOGE, FL(" ****SoftAP mode already exists ****"));
return eHAL_STATUS_FAILURE;
}
else if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_P2P_GO_MODE) &&
(pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
{
smsLog(pMac, LOGE, FL(" ****Cannot start Multiple Beaconing Role ****"));
return eHAL_STATUS_FAILURE;
}
break;
case VOS_P2P_GO_MODE:
if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_P2P_GO_MODE) &&
(pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
{
smsLog(pMac, LOGE, FL(" ****P2P GO mode already exists ****"));
return eHAL_STATUS_FAILURE;
}
else if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_STA_SAP_MODE) &&
(pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
{
smsLog(pMac, LOGE, FL(" ****Cannot start Multiple Beaconing Role ****"));
return eHAL_STATUS_FAILURE;
}
break;
default :
smsLog(pMac, LOGE, FL("***Persona not handled = %d*****"),currBssPersona);
break;
}
}
}
return eHAL_STATUS_SUCCESS;
}
eHalStatus csrUpdateMCCp2pBeaconInterval(tpAniSirGlobal pMac)
{
tANI_U32 sessionId = 0;
//If MCC is not supported just break and return SUCCESS
if ( !pMac->roam.configParam.fenableMCCMode){
return eHAL_STATUS_FAILURE;
}
for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
{
/* If GO in MCC support different beacon interval,
* change the BI of the P2P-GO */
if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_P2P_GO_MODE)
{
/* Handle different BI scneario based on the configuration set.
* If Config is set to 0x02 then Disconnect all the P2P clients
* associated. If config is set to 0x04 then update the BI
* without disconnecting all the clients
*/
if ((pMac->roam.configParam.fAllowMCCGODiffBI == 0x04) &&
(pMac->roam.roamSession[sessionId].bssParams.updatebeaconInterval))
{
return csrSendChngMCCBeaconInterval( pMac, sessionId);
}
//If the configuration of fAllowMCCGODiffBI is set to other than 0x04
else if ( pMac->roam.roamSession[sessionId].bssParams.updatebeaconInterval)
{
return csrRoamCallCallback(pMac, sessionId, NULL, 0, eCSR_ROAM_DISCONNECT_ALL_P2P_CLIENTS, eCSR_ROAM_RESULT_NONE);
}
}
}
return eHAL_STATUS_FAILURE;
}
tANI_U16 csrCalculateMCCBeaconInterval(tpAniSirGlobal pMac, tANI_U16 sta_bi, tANI_U16 go_gbi)
{
tANI_U8 num_beacons = 0;
tANI_U8 is_multiple = 0;
tANI_U16 go_cbi = 0;
tANI_U16 go_fbi = 0;
tANI_U16 sta_cbi = 0;
//If GO's given beacon Interval is less than 100
if(go_gbi < 100)
go_cbi = 100;
//if GO's given beacon Interval is greater than or equal to 100
else
go_cbi = 100 + (go_gbi % 100);
// check, if either one is multiple of another
if (sta_bi > go_cbi)
{
is_multiple = !(sta_bi % go_cbi);
}
else
{
is_multiple = !(go_cbi % sta_bi);
}
// if it is multiple, then accept GO's beacon interval range [100,199] as it is
if (is_multiple)
{
return go_cbi;
}
//else , if it is not multiple, then then check for number of beacons to be
//inserted based on sta BI
num_beacons = sta_bi / 100;
if (num_beacons)
{
// GO's final beacon interval will be aligned to sta beacon interval, but
//in the range of [100, 199].
sta_cbi = sta_bi / num_beacons;
go_fbi = sta_cbi;
}
else
{
// if STA beacon interval is less than 100, use GO's change bacon interval
//instead of updating to STA's beacon interval.
go_fbi = go_cbi;
}
return go_fbi;
}
eHalStatus csrValidateMCCBeaconInterval(tpAniSirGlobal pMac, tANI_U8 channelId,
tANI_U16 *beaconInterval, tANI_U32 cursessionId,
tVOS_CON_MODE currBssPersona)
{
tANI_U32 sessionId = 0;
tANI_U16 new_beaconInterval = 0;
//If MCC is not supported just break
if (!pMac->roam.configParam.fenableMCCMode){
return eHAL_STATUS_FAILURE;
}
for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
{
if (cursessionId != sessionId )
{
if (!CSR_IS_SESSION_VALID( pMac, sessionId ))
{
continue;
}
switch (currBssPersona)
{
case VOS_STA_MODE:
if (pMac->roam.roamSession[sessionId].pCurRoamProfile &&
(pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
== VOS_P2P_CLIENT_MODE)) //check for P2P client mode
{
smsLog(pMac, LOG1, FL(" Beacon Interval Validation not required for STA/CLIENT"));
}
//IF SAP has started and STA wants to connect on different channel MCC should
//MCC should not be enabled so making it false to enforce on same channel
else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_STA_SAP_MODE)
{
if (pMac->roam.roamSession[sessionId].bssParams.operationChn
!= channelId )
{
smsLog(pMac, LOGE, FL("***MCC is not enabled for SAP +STA****"));
return eHAL_STATUS_FAILURE;
}
}
else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_P2P_GO_MODE) //Check for P2P go scenario
{
/* if GO in MCC support different beacon interval,
* change the BI of the P2P-GO */
if ((pMac->roam.roamSession[sessionId].bssParams.operationChn
!= channelId ) &&
(pMac->roam.roamSession[sessionId].bssParams.beaconInterval
!= *beaconInterval))
{
/* if GO in MCC support different beacon interval, return success */
if ( pMac->roam.configParam.fAllowMCCGODiffBI == 0x01)
{
return eHAL_STATUS_SUCCESS;
}
// Send only Broadcast disassoc and update beaconInterval
//If configuration is set to 0x04 then dont
// disconnect all the station
else if ((pMac->roam.configParam.fAllowMCCGODiffBI == 0x02) ||
(pMac->roam.configParam.fAllowMCCGODiffBI == 0x04))
{
//Check to pass the right beacon Interval
new_beaconInterval = csrCalculateMCCBeaconInterval(pMac, *beaconInterval,
pMac->roam.roamSession[sessionId].bssParams.beaconInterval);
smsLog(pMac, LOG1, FL(" Peer AP BI : %d, new Beacon Interval: %d"),*beaconInterval,new_beaconInterval );
//Update the becon Interval
if (new_beaconInterval != pMac->roam.roamSession[sessionId].bssParams.beaconInterval)
{
//Update the beaconInterval now
smsLog(pMac, LOGE, FL(" Beacon Interval got changed config used: %d\n"),
pMac->roam.configParam.fAllowMCCGODiffBI);
pMac->roam.roamSession[sessionId].bssParams.beaconInterval = new_beaconInterval;
pMac->roam.roamSession[sessionId].bssParams.updatebeaconInterval = eANI_BOOLEAN_TRUE;
return csrUpdateMCCp2pBeaconInterval(pMac);
}
return eHAL_STATUS_SUCCESS;
}
//Disconnect the P2P session
else if (pMac->roam.configParam.fAllowMCCGODiffBI == 0x03)
{
pMac->roam.roamSession[sessionId].bssParams.updatebeaconInterval = eANI_BOOLEAN_FALSE;
return csrRoamCallCallback(pMac, sessionId, NULL, 0, eCSR_ROAM_SEND_P2P_STOP_BSS, eCSR_ROAM_RESULT_NONE);
}
else
{
smsLog(pMac, LOGE, FL("BeaconInterval is different cannot connect to preferred AP..."));
return eHAL_STATUS_FAILURE;
}
}
}
break;
case VOS_P2P_CLIENT_MODE:
if (pMac->roam.roamSession[sessionId].pCurRoamProfile &&
(pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
== VOS_STA_MODE)) //check for P2P client mode
{
smsLog(pMac, LOG1, FL(" Ignore Beacon Interval Validation..."));
}
//IF SAP has started and STA wants to connect on different channel MCC should
//MCC should not be enabled so making it false to enforce on same channel
else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_STA_SAP_MODE)
{
if (pMac->roam.roamSession[sessionId].bssParams.operationChn
!= channelId )
{
smsLog(pMac, LOGE, FL("***MCC is not enabled for SAP + CLIENT****"));
return eHAL_STATUS_FAILURE;
}
}
else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
== VOS_P2P_GO_MODE) //Check for P2P go scenario
{
if ((pMac->roam.roamSession[sessionId].bssParams.operationChn
!= channelId ) &&
(pMac->roam.roamSession[sessionId].bssParams.beaconInterval
!= *beaconInterval))
{
smsLog(pMac, LOGE, FL("BeaconInterval is different cannot connect to P2P_GO network ..."));
return eHAL_STATUS_FAILURE;
}
}
break;
case VOS_P2P_GO_MODE :
{
if (pMac->roam.roamSession[sessionId].pCurRoamProfile &&
((pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
== VOS_P2P_CLIENT_MODE) ||
(pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
== VOS_STA_MODE))) //check for P2P_client scenario
{
if ((pMac->roam.roamSession[sessionId].connectedProfile.operationChannel
== 0 )&&
(pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval
== 0))
{
continue;
}
if (csrIsConnStateConnectedInfra(pMac, sessionId) &&
(pMac->roam.roamSession[sessionId].connectedProfile.operationChannel
!= channelId ) &&
(pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval
!= *beaconInterval))
{
/*
* Updated beaconInterval should be used only when we are starting a new BSS
* not incase of client or STA case
*/
//Calculate beacon Interval for P2P-GO incase of MCC
new_beaconInterval = csrCalculateMCCBeaconInterval(pMac,
pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval,
*beaconInterval );
if(*beaconInterval != new_beaconInterval)
*beaconInterval = new_beaconInterval;
return eHAL_STATUS_SUCCESS;
}
}
}
break;
default :
smsLog(pMac, LOG1, FL(" Persona not supported : %d"),currBssPersona);
return eHAL_STATUS_FAILURE;
}
}
}
return eHAL_STATUS_SUCCESS;
}
#ifdef WLAN_FEATURE_VOWIFI_11R
/* Function to return TRUE if the authtype is 11r */
tANI_BOOLEAN csrIsAuthType11r( eCsrAuthType AuthType, tANI_U8 mdiePresent)
{
switch ( AuthType )
{
case eCSR_AUTH_TYPE_OPEN_SYSTEM:
if(mdiePresent)
return TRUE;
break;
case eCSR_AUTH_TYPE_FT_RSN_PSK:
case eCSR_AUTH_TYPE_FT_RSN:
return TRUE;
break;
default:
break;
}
return FALSE;
}
/* Function to return TRUE if the profile is 11r */
tANI_BOOLEAN csrIsProfile11r( tCsrRoamProfile *pProfile )
{
return csrIsAuthType11r( pProfile->negotiatedAuthType, pProfile->MDID.mdiePresent );
}
#endif
#ifdef FEATURE_WLAN_CCX
/* Function to return TRUE if the authtype is CCX */
tANI_BOOLEAN csrIsAuthTypeCCX( eCsrAuthType AuthType )
{
switch ( AuthType )
{
case eCSR_AUTH_TYPE_CCKM_WPA:
case eCSR_AUTH_TYPE_CCKM_RSN:
return TRUE;
break;
default:
break;
}
return FALSE;
}
/* Function to return TRUE if the profile is CCX */
tANI_BOOLEAN csrIsProfileCCX( tCsrRoamProfile *pProfile )
{
return (csrIsAuthTypeCCX( pProfile->negotiatedAuthType ));
}
#endif
#ifdef FEATURE_WLAN_WAPI
tANI_BOOLEAN csrIsProfileWapi( tCsrRoamProfile *pProfile )
{
tANI_BOOLEAN fWapiProfile = FALSE;
switch ( pProfile->negotiatedAuthType )
{
case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
fWapiProfile = TRUE;
break;
default:
fWapiProfile = FALSE;
break;
}
if ( fWapiProfile )
{
switch ( pProfile->negotiatedUCEncryptionType )
{
case eCSR_ENCRYPT_TYPE_WPI:
fWapiProfile = TRUE;
break;
default:
fWapiProfile = FALSE;
break;
}
}
return( fWapiProfile );
}
static tANI_BOOLEAN csrIsWapiOuiEqual( tpAniSirGlobal pMac, tANI_U8 *Oui1, tANI_U8 *Oui2 )
{
return( palEqualMemory(pMac->hHdd, Oui1, Oui2, CSR_WAPI_OUI_SIZE ) );
}
static tANI_BOOLEAN csrIsWapiOuiMatch( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WAPI_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Cypher[],
tANI_U8 Oui[] )
{
tANI_BOOLEAN fYes = FALSE;
tANI_U8 idx;
for ( idx = 0; idx < cAllCyphers; idx++ )
{
if ( csrIsWapiOuiEqual( pMac, AllCyphers[ idx ], Cypher ) )
{
fYes = TRUE;
break;
}
}
if ( fYes && Oui )
{
palCopyMemory( pMac->hHdd, Oui, AllCyphers[ idx ], CSR_WAPI_OUI_SIZE );
}
return( fYes );
}
#endif /* FEATURE_WLAN_WAPI */
static tANI_BOOLEAN csrIsWpaOuiEqual( tpAniSirGlobal pMac, tANI_U8 *Oui1, tANI_U8 *Oui2 )
{
return( palEqualMemory(pMac->hHdd, Oui1, Oui2, CSR_WPA_OUI_SIZE ) );
}
static tANI_BOOLEAN csrIsOuiMatch( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Cypher[],
tANI_U8 Oui[] )
{
tANI_BOOLEAN fYes = FALSE;
tANI_U8 idx;
for ( idx = 0; idx < cAllCyphers; idx++ )
{
if ( csrIsWpaOuiEqual( pMac, AllCyphers[ idx ], Cypher ) )
{
fYes = TRUE;
break;
}
}
if ( fYes && Oui )
{
palCopyMemory( pMac->hHdd, Oui, AllCyphers[ idx ], CSR_WPA_OUI_SIZE );
}
return( fYes );
}
static tANI_BOOLEAN csrMatchRSNOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui[ouiIndex], Oui ) );
}
#ifdef FEATURE_WLAN_WAPI
static tANI_BOOLEAN csrMatchWapiOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WAPI_OUI_SIZE],
tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
tANI_U8 Oui[] )
{
return( csrIsWapiOuiMatch( pMac, AllCyphers, cAllCyphers, csrWapiOui[ouiIndex], Oui ) );
}
#endif /* FEATURE_WLAN_WAPI */
static tANI_BOOLEAN csrMatchWPAOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui[ouiIndex], Oui ) );
}
#if 0
static tANI_BOOLEAN csrIsRSNUnicastNone( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui00, Oui ) );
}
static tANI_BOOLEAN csrIsRSNMulticastWep( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
tANI_BOOLEAN fYes = FALSE;
// Check Wep 104 first, if fails, then check Wep40.
fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui05, Oui );
if ( !fYes )
{
// if not Wep-104, check Wep-40
fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui01, Oui );
}
return( fYes );
}
static tANI_BOOLEAN csrIsRSNUnicastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui02, Oui ) );
}
static tANI_BOOLEAN csrIsRSNMulticastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui02, Oui ) );
}
static tANI_BOOLEAN csrIsRSNUnicastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui04, Oui ) );
}
static tANI_BOOLEAN csrIsRSNMulticastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui04, Oui ) );
}
#endif
#ifdef FEATURE_WLAN_WAPI
static tANI_BOOLEAN csrIsAuthWapiCert( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WAPI_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsWapiOuiMatch( pMac, AllSuites, cAllSuites, csrWapiOui[1], Oui ) );
}
static tANI_BOOLEAN csrIsAuthWapiPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WAPI_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsWapiOuiMatch( pMac, AllSuites, cAllSuites, csrWapiOui[2], Oui ) );
}
#endif /* FEATURE_WLAN_WAPI */
#ifdef WLAN_FEATURE_VOWIFI_11R
/*
* Function for 11R FT Authentication. We match the FT Authentication Cipher suite
* here. This matches for FT Auth with the 802.1X exchange.
*
*/
static tANI_BOOLEAN csrIsFTAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[03], Oui ) );
}
/*
* Function for 11R FT Authentication. We match the FT Authentication Cipher suite
* here. This matches for FT Auth with the PSK.
*
*/
static tANI_BOOLEAN csrIsFTAuthRSNPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[04], Oui ) );
}
#endif
#ifdef FEATURE_WLAN_CCX
/*
* Function for CCX CCKM AKM Authentication. We match the CCKM AKM Authentication Key Management suite
* here. This matches for CCKM AKM Auth with the 802.1X exchange.
*
*/
static tANI_BOOLEAN csrIsCcxCckmAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[06], Oui ) );
}
static tANI_BOOLEAN csrIsCcxCckmAuthWpa( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[06], Oui ) );
}
#endif
static tANI_BOOLEAN csrIsAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[01], Oui ) );
}
static tANI_BOOLEAN csrIsAuthRSNPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[02], Oui ) );
}
#ifdef WLAN_FEATURE_11W
static tANI_BOOLEAN csrIsAuthRSNPskSha256( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[07], Oui );
}
#endif
static tANI_BOOLEAN csrIsAuthWpa( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[01], Oui ) );
}
#ifdef NOT_CURRENTLY_USED
static tANI_BOOLEAN csrIsAuth802_1x( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[00], Oui ) );
}
#endif // NOT_CURRENTLY_USED
static tANI_BOOLEAN csrIsAuthWpaPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllSuites,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[02], Oui ) );
}
#if 0
static tANI_BOOLEAN csrIsUnicastNone( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui00, Oui ) );
}
static tANI_BOOLEAN csrIsUnicastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui02, Oui ) );
}
static tANI_BOOLEAN csrIsUnicastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui04, Oui ) );
}
static tANI_BOOLEAN csrIsMulticastWep( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
tANI_BOOLEAN fYes = FALSE;
// Check Wep 104 first, if fails, then check Wep40.
fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui05, Oui );
if ( !fYes )
{
// if not Wep-104, check Wep-40
fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui01, Oui );
}
return( fYes );
}
static tANI_BOOLEAN csrIsMulticastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui02, Oui ) );
}
static tANI_BOOLEAN csrIsMulticastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
tANI_U8 cAllCyphers,
tANI_U8 Oui[] )
{
return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui04, Oui ) );
}
#endif
tANI_U8 csrGetOUIIndexFromCipher( eCsrEncryptionType enType )
{
tANI_U8 OUIIndex;
switch ( enType )
{
case eCSR_ENCRYPT_TYPE_WEP40:
case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
OUIIndex = CSR_OUI_WEP40_OR_1X_INDEX;
break;
case eCSR_ENCRYPT_TYPE_WEP104:
case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
OUIIndex = CSR_OUI_WEP104_INDEX;
break;
case eCSR_ENCRYPT_TYPE_TKIP:
OUIIndex = CSR_OUI_TKIP_OR_PSK_INDEX;
break;
case eCSR_ENCRYPT_TYPE_AES:
OUIIndex = CSR_OUI_AES_INDEX;
break;
case eCSR_ENCRYPT_TYPE_NONE:
OUIIndex = CSR_OUI_USE_GROUP_CIPHER_INDEX;
break;
#ifdef FEATURE_WLAN_WAPI
case eCSR_ENCRYPT_TYPE_WPI:
OUIIndex = CSR_OUI_WAPI_WAI_CERT_OR_SMS4_INDEX;
break;
#endif /* FEATURE_WLAN_WAPI */
default: //HOWTO handle this?
OUIIndex = CSR_OUI_RESERVED_INDEX;
break;
}//switch
return OUIIndex;
}
tANI_BOOLEAN csrGetRSNInformation( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
tDot11fIERSN *pRSNIe,
tANI_U8 *UnicastCypher,
tANI_U8 *MulticastCypher,
tANI_U8 *AuthSuite,
tCsrRSNCapabilities *Capabilities,
eCsrAuthType *pNegotiatedAuthtype,
eCsrEncryptionType *pNegotiatedMCCipher )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fAcceptableCyphers = FALSE;
tANI_U8 cUnicastCyphers = 0;
tANI_U8 cMulticastCyphers = 0;
tANI_U8 cAuthSuites = 0, i;
tANI_U8 Unicast[ CSR_RSN_OUI_SIZE ];
tANI_U8 Multicast[ CSR_RSN_OUI_SIZE ];
tANI_U8 AuthSuites[ CSR_RSN_MAX_AUTH_SUITES ][ CSR_RSN_OUI_SIZE ];
tANI_U8 Authentication[ CSR_RSN_OUI_SIZE ];
tANI_U8 MulticastCyphers[ CSR_RSN_MAX_MULTICAST_CYPHERS ][ CSR_RSN_OUI_SIZE ];
eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
do{
if ( pRSNIe->present )
{
cMulticastCyphers++;
palCopyMemory(pMac->hHdd, MulticastCyphers, pRSNIe->gp_cipher_suite, CSR_RSN_OUI_SIZE);
cUnicastCyphers = (tANI_U8)(pRSNIe->pwise_cipher_suite_count);
cAuthSuites = (tANI_U8)(pRSNIe->akm_suite_count);
for(i = 0; i < cAuthSuites && i < CSR_RSN_MAX_AUTH_SUITES; i++)
{
palCopyMemory(pMac->hHdd, (void *)&AuthSuites[i],
(void *)&pRSNIe->akm_suites[i], CSR_RSN_OUI_SIZE);
}
//Check - Is requested Unicast Cipher supported by the BSS.
fAcceptableCyphers = csrMatchRSNOUIIndex( pMac, pRSNIe->pwise_cipher_suites, cUnicastCyphers,
csrGetOUIIndexFromCipher( enType ), Unicast );
if( !fAcceptableCyphers ) break;
//Unicast is supported. Pick the first matching Group cipher, if any.
for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
{
fAcceptableCyphers = csrMatchRSNOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i] ), Multicast );
if(fAcceptableCyphers)
{
break;
}
}
if( !fAcceptableCyphers ) break;
if( pNegotiatedMCCipher )
*pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
/* Initializing with FALSE as it has TRUE value already */
fAcceptableCyphers = FALSE;
for (i = 0 ; i < pAuthType->numEntries; i++)
{
//Ciphers are supported, Match authentication algorithm and pick first matching authtype.
#ifdef WLAN_FEATURE_VOWIFI_11R
/* Changed the AKM suites according to order of preference */
if ( csrIsFTAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_FT_RSN == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_FT_RSN;
}
if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsFTAuthRSNPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_FT_RSN_PSK == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_FT_RSN_PSK;
}
#endif
#ifdef FEATURE_WLAN_CCX
/* CCX only supports 802.1X. No PSK. */
if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsCcxCckmAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_CCKM_RSN == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_CCKM_RSN;
}
#endif
if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_RSN == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_RSN;
}
if ((negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthRSNPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_RSN_PSK == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_RSN_PSK;
}
#ifdef WLAN_FEATURE_11W
if ((negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthRSNPskSha256( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_RSN_PSK_SHA256 == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_RSN_PSK_SHA256;
}
#endif
// The 1st auth type in the APs RSN IE, to match stations connecting
// profiles auth type will cause us to exit this loop
// This is added as some APs advertise multiple akms in the RSN IE.
if (eCSR_AUTH_TYPE_UNKNOWN != negAuthType)
{
fAcceptableCyphers = TRUE;
break;
}
} // for
}
}while (0);
if ( fAcceptableCyphers )
{
if ( MulticastCypher )
{
palCopyMemory( pMac->hHdd, MulticastCypher, Multicast, CSR_RSN_OUI_SIZE );
}
if ( UnicastCypher )
{
palCopyMemory( pMac->hHdd, UnicastCypher, Unicast, CSR_RSN_OUI_SIZE );
}
if ( AuthSuite )
{
palCopyMemory( pMac->hHdd, AuthSuite, Authentication, CSR_RSN_OUI_SIZE );
}
if ( pNegotiatedAuthtype )
{
*pNegotiatedAuthtype = negAuthType;
}
if ( Capabilities )
{
Capabilities->PreAuthSupported = (pRSNIe->RSN_Cap[0] >> 0) & 0x1 ; // Bit 0 PreAuthentication
Capabilities->NoPairwise = (pRSNIe->RSN_Cap[0] >> 1) & 0x1 ; // Bit 1 No Pairwise
Capabilities->PTKSAReplayCounter = (pRSNIe->RSN_Cap[0] >> 2) & 0x3 ; // Bit 2, 3 PTKSA Replay Counter
Capabilities->GTKSAReplayCounter = (pRSNIe->RSN_Cap[0] >> 4) & 0x3 ; // Bit 4, 5 GTKSA Replay Counter
#ifdef WLAN_FEATURE_11W
Capabilities->MFPRequired = (pRSNIe->RSN_Cap[0] >> 6) & 0x1 ; // Bit 6 MFPR
Capabilities->MFPCapable = (pRSNIe->RSN_Cap[0] >> 7) & 0x1 ; // Bit 7 MFPC
#endif
Capabilities->Reserved = pRSNIe->RSN_Cap[1] & 0xff ; // remaining reserved
}
}
return( fAcceptableCyphers );
}
tANI_BOOLEAN csrIsRSNMatch( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCCipher )
{
tANI_BOOLEAN fRSNMatch = FALSE;
// See if the cyphers in the Bss description match with the settings in the profile.
fRSNMatch = csrGetRSNInformation( hHal, pAuthType, enType, pEnMcType, &pIes->RSN, NULL, NULL, NULL, NULL,
pNegotiatedAuthType, pNegotiatedMCCipher );
return( fRSNMatch );
}
tANI_BOOLEAN csrLookupPMKID( tpAniSirGlobal pMac, tANI_U32 sessionId, tANI_U8 *pBSSId, tANI_U8 *pPMKId )
{
tANI_BOOLEAN fRC = FALSE, fMatchFound = FALSE;
tANI_U32 Index;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
if(!pSession)
{
smsLog(pMac, LOGE, FL(" session %d not found "), sessionId);
return FALSE;
}
/* to force the AP initiate fresh 802.1x authentication after re-association should not
* fill the PMKID from cache this is needed
* by the HS 2.0 passpoint certification 5.2.a and b testcases */
if(pSession->fIgnorePMKIDCache)
{
pSession->fIgnorePMKIDCache = FALSE;
return fRC;
}
do
{
for( Index=0; Index < pSession->NumPmkidCache; Index++ )
{
smsLog(pMac, LOGW, "match PMKID %02X-%02X-%02X-%02X-%02X-%02X to ",
pBSSId[0], pBSSId[1], pBSSId[2], pBSSId[3], pBSSId[4], pBSSId[5]);
if( palEqualMemory( pMac->hHdd, pBSSId, pSession->PmkidCacheInfo[Index].BSSID, sizeof(tCsrBssid) ) )
{
// match found
fMatchFound = TRUE;
break;
}
}
if( !fMatchFound ) break;
palCopyMemory( pMac->hHdd, pPMKId, pSession->PmkidCacheInfo[Index].PMKID, CSR_RSN_PMKID_SIZE );
fRC = TRUE;
}
while( 0 );
smsLog(pMac, LOGW, "csrLookupPMKID called return match = %d pMac->roam.NumPmkidCache = %d",
fRC, pSession->NumPmkidCache);
return fRC;
}
tANI_U8 csrConstructRSNIe( tHalHandle hHal, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrRSNIe *pRSNIe )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fRSNMatch;
tANI_U8 cbRSNIe = 0;
tANI_U8 UnicastCypher[ CSR_RSN_OUI_SIZE ];
tANI_U8 MulticastCypher[ CSR_RSN_OUI_SIZE ];
tANI_U8 AuthSuite[ CSR_RSN_OUI_SIZE ];
tCsrRSNAuthIe *pAuthSuite;
tCsrRSNCapabilities RSNCapabilities;
tCsrRSNPMKIe *pPMK;
tANI_U8 PMKId[CSR_RSN_PMKID_SIZE];
tDot11fBeaconIEs *pIesLocal = pIes;
smsLog(pMac, LOGW, "%s called...", __func__);
do
{
if ( !csrIsProfileRSN( pProfile ) ) break;
if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
{
break;
}
// See if the cyphers in the Bss description match with the settings in the profile.
fRSNMatch = csrGetRSNInformation( hHal, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType,
&pProfile->mcEncryptionType, &pIesLocal->RSN,
UnicastCypher, MulticastCypher, AuthSuite, &RSNCapabilities, NULL, NULL );
if ( !fRSNMatch ) break;
pRSNIe->IeHeader.ElementID = SIR_MAC_RSN_EID;
pRSNIe->Version = CSR_RSN_VERSION_SUPPORTED;
palCopyMemory( pMac->hHdd, pRSNIe->MulticastOui, MulticastCypher, sizeof( MulticastCypher ) );
pRSNIe->cUnicastCyphers = 1;
palCopyMemory( pMac->hHdd, &pRSNIe->UnicastOui[ 0 ], UnicastCypher, sizeof( UnicastCypher ) );
pAuthSuite = (tCsrRSNAuthIe *)( &pRSNIe->UnicastOui[ pRSNIe->cUnicastCyphers ] );
pAuthSuite->cAuthenticationSuites = 1;
palCopyMemory( pMac->hHdd, &pAuthSuite->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
// RSN capabilities follows the Auth Suite (two octects)
// !!REVIEW - What should STA put in RSN capabilities, currently
// just putting back APs capabilities
// For one, we shouldn't EVER be sending out "pre-auth supported". It is an AP only capability
// For another, we should use the Management Frame Protection values given by the supplicant
RSNCapabilities.PreAuthSupported = 0;
#ifdef WLAN_FEATURE_11W
RSNCapabilities.MFPRequired = pProfile->MFPRequired;
RSNCapabilities.MFPCapable = pProfile->MFPCapable;
#endif
*(tANI_U16 *)( &pAuthSuite->AuthOui[ 1 ] ) = *((tANI_U16 *)(&RSNCapabilities));
pPMK = (tCsrRSNPMKIe *)( ((tANI_U8 *)(&pAuthSuite->AuthOui[ 1 ])) + sizeof(tANI_U16) );
if( csrLookupPMKID( pMac, sessionId, pSirBssDesc->bssId, &(PMKId[0]) ) )
{
pPMK->cPMKIDs = 1;
palCopyMemory( pMac->hHdd, pPMK->PMKIDList[0].PMKID, PMKId, CSR_RSN_PMKID_SIZE );
}
else
{
pPMK->cPMKIDs = 0;
}
// Add in the fixed fields plus 1 Unicast cypher, less the IE Header length
// Add in the size of the Auth suite (count plus a single OUI)
// Add in the RSN caps field.
// Add PMKID count and PMKID (if any)
pRSNIe->IeHeader.Length = (tANI_U8) (sizeof( *pRSNIe ) - sizeof ( pRSNIe->IeHeader ) +
sizeof( *pAuthSuite ) +
sizeof( tCsrRSNCapabilities ));
if(pPMK->cPMKIDs)
{
pRSNIe->IeHeader.Length += (tANI_U8)(sizeof( tANI_U16 ) +
(pPMK->cPMKIDs * CSR_RSN_PMKID_SIZE));
}
// return the size of the IE header (total) constructed...
cbRSNIe = pRSNIe->IeHeader.Length + sizeof( pRSNIe->IeHeader );
} while( 0 );
if( !pIes && pIesLocal )
{
//locally allocated
palFreeMemory(pMac->hHdd, pIesLocal);
}
return( cbRSNIe );
}
#ifdef FEATURE_WLAN_WAPI
tANI_BOOLEAN csrGetWapiInformation( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
tDot11fIEWAPI *pWapiIe,
tANI_U8 *UnicastCypher,
tANI_U8 *MulticastCypher,
tANI_U8 *AuthSuite,
eCsrAuthType *pNegotiatedAuthtype,
eCsrEncryptionType *pNegotiatedMCCipher )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fAcceptableCyphers = FALSE;
tANI_U8 cUnicastCyphers = 0;
tANI_U8 cMulticastCyphers = 0;
tANI_U8 cAuthSuites = 0, i;
tANI_U8 Unicast[ CSR_WAPI_OUI_SIZE ];
tANI_U8 Multicast[ CSR_WAPI_OUI_SIZE ];
tANI_U8 AuthSuites[ CSR_WAPI_MAX_AUTH_SUITES ][ CSR_WAPI_OUI_SIZE ];
tANI_U8 Authentication[ CSR_WAPI_OUI_SIZE ];
tANI_U8 MulticastCyphers[ CSR_WAPI_MAX_MULTICAST_CYPHERS ][ CSR_WAPI_OUI_SIZE ];
eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
do{
if ( pWapiIe->present )
{
cMulticastCyphers++;
palCopyMemory(pMac->hHdd, MulticastCyphers, pWapiIe->multicast_cipher_suite, CSR_WAPI_OUI_SIZE);
cUnicastCyphers = (tANI_U8)(pWapiIe->unicast_cipher_suite_count);
cAuthSuites = (tANI_U8)(pWapiIe->akm_suite_count);
for(i = 0; i < cAuthSuites && i < CSR_WAPI_MAX_AUTH_SUITES; i++)
{
palCopyMemory(pMac->hHdd, (void *)&AuthSuites[i],
(void *)&pWapiIe->akm_suites[i], CSR_WAPI_OUI_SIZE);
}
//Check - Is requested Unicast Cipher supported by the BSS.
fAcceptableCyphers = csrMatchWapiOUIIndex( pMac, pWapiIe->unicast_cipher_suites, cUnicastCyphers,
csrGetOUIIndexFromCipher( enType ), Unicast );
if( !fAcceptableCyphers ) break;
//Unicast is supported. Pick the first matching Group cipher, if any.
for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
{
fAcceptableCyphers = csrMatchWapiOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i] ), Multicast );
if(fAcceptableCyphers)
{
break;
}
}
if( !fAcceptableCyphers ) break;
if( pNegotiatedMCCipher )
*pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
//Ciphers are supported, Match authentication algorithm and pick first matching authtype.
if ( csrIsAuthWapiCert( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
negAuthType = eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
}
else if ( csrIsAuthWapiPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
{
negAuthType = eCSR_AUTH_TYPE_WAPI_WAI_PSK;
}
else
{
fAcceptableCyphers = FALSE;
negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
}
if( ( 0 == pAuthType->numEntries ) || ( FALSE == fAcceptableCyphers ) )
{
//Caller doesn't care about auth type, or BSS doesn't match
break;
}
fAcceptableCyphers = FALSE;
for( i = 0 ; i < pAuthType->numEntries; i++ )
{
if( pAuthType->authType[i] == negAuthType )
{
fAcceptableCyphers = TRUE;
break;
}
}
}
}while (0);
if ( fAcceptableCyphers )
{
if ( MulticastCypher )
{
palCopyMemory( pMac->hHdd, MulticastCypher, Multicast, CSR_WAPI_OUI_SIZE );
}
if ( UnicastCypher )
{
palCopyMemory( pMac->hHdd, UnicastCypher, Unicast, CSR_WAPI_OUI_SIZE );
}
if ( AuthSuite )
{
palCopyMemory( pMac->hHdd, AuthSuite, Authentication, CSR_WAPI_OUI_SIZE );
}
if ( pNegotiatedAuthtype )
{
*pNegotiatedAuthtype = negAuthType;
}
}
return( fAcceptableCyphers );
}
tANI_BOOLEAN csrIsWapiMatch( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCCipher )
{
tANI_BOOLEAN fWapiMatch = FALSE;
// See if the cyphers in the Bss description match with the settings in the profile.
fWapiMatch = csrGetWapiInformation( hHal, pAuthType, enType, pEnMcType, &pIes->WAPI, NULL, NULL, NULL,
pNegotiatedAuthType, pNegotiatedMCCipher );
return( fWapiMatch );
}
tANI_BOOLEAN csrLookupBKID( tpAniSirGlobal pMac, tANI_U32 sessionId, tANI_U8 *pBSSId, tANI_U8 *pBKId )
{
tANI_BOOLEAN fRC = FALSE, fMatchFound = FALSE;
tANI_U32 Index;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
if(!pSession)
{
smsLog(pMac, LOGE, FL(" session %d not found "), sessionId);
return FALSE;
}
do
{
for( Index=0; Index < pSession->NumBkidCache; Index++ )
{
smsLog(pMac, LOGW, "match BKID %02X-%02X-%02X-%02X-%02X-%02X to ",
pBSSId[0], pBSSId[1], pBSSId[2], pBSSId[3], pBSSId[4], pBSSId[5]);
if( palEqualMemory( pMac->hHdd, pBSSId, pSession->BkidCacheInfo[Index].BSSID, sizeof(tCsrBssid) ) )
{
// match found
fMatchFound = TRUE;
break;
}
}
if( !fMatchFound ) break;
palCopyMemory( pMac->hHdd, pBKId, pSession->BkidCacheInfo[Index].BKID, CSR_WAPI_BKID_SIZE );
fRC = TRUE;
}
while( 0 );
smsLog(pMac, LOGW, "csrLookupBKID called return match = %d pMac->roam.NumBkidCache = %d", fRC, pSession->NumBkidCache);
return fRC;
}
tANI_U8 csrConstructWapiIe( tpAniSirGlobal pMac, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrWapiIe *pWapiIe )
{
tANI_BOOLEAN fWapiMatch = FALSE;
tANI_U8 cbWapiIe = 0;
tANI_U8 UnicastCypher[ CSR_WAPI_OUI_SIZE ];
tANI_U8 MulticastCypher[ CSR_WAPI_OUI_SIZE ];
tANI_U8 AuthSuite[ CSR_WAPI_OUI_SIZE ];
tANI_U8 BKId[CSR_WAPI_BKID_SIZE];
tANI_U8 *pWapi = NULL;
tANI_BOOLEAN fBKIDFound = FALSE;
tDot11fBeaconIEs *pIesLocal = pIes;
do
{
if ( !csrIsProfileWapi( pProfile ) ) break;
if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
{
break;
}
// See if the cyphers in the Bss description match with the settings in the profile.
fWapiMatch = csrGetWapiInformation( pMac, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType,
&pProfile->mcEncryptionType, &pIesLocal->WAPI,
UnicastCypher, MulticastCypher, AuthSuite, NULL, NULL );
if ( !fWapiMatch ) break;
palZeroMemory(pMac->hHdd, pWapiIe, sizeof(tCsrWapiIe));
pWapiIe->IeHeader.ElementID = DOT11F_EID_WAPI;
pWapiIe->Version = CSR_WAPI_VERSION_SUPPORTED;
pWapiIe->cAuthenticationSuites = 1;
palCopyMemory( pMac->hHdd, &pWapiIe->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
pWapi = (tANI_U8 *) (&pWapiIe->AuthOui[ 1 ]);
*pWapi = (tANI_U16)1; //cUnicastCyphers
pWapi+=2;
palCopyMemory( pMac->hHdd, pWapi, UnicastCypher, sizeof( UnicastCypher ) );
pWapi += sizeof( UnicastCypher );
palCopyMemory( pMac->hHdd, pWapi, MulticastCypher, sizeof( MulticastCypher ) );
pWapi += sizeof( MulticastCypher );
// WAPI capabilities follows the Auth Suite (two octects)
// we shouldn't EVER be sending out "pre-auth supported". It is an AP only capability
// & since we already did a memset pWapiIe to 0, skip these fields
pWapi +=2;
fBKIDFound = csrLookupBKID( pMac, sessionId, pSirBssDesc->bssId, &(BKId[0]) );
if( fBKIDFound )
{
/* Do we need to change the endianness here */
*pWapi = (tANI_U16)1; //cBKIDs
pWapi+=2;
palCopyMemory( pMac->hHdd, pWapi, BKId, CSR_WAPI_BKID_SIZE );
}
else
{
*pWapi = 0;
pWapi+=1;
*pWapi = 0;
pWapi+=1;
}
// Add in the IE fields except the IE header
// Add BKID count and BKID (if any)
pWapiIe->IeHeader.Length = (tANI_U8) (sizeof( *pWapiIe ) - sizeof ( pWapiIe->IeHeader ));
/*2 bytes for BKID Count field*/
pWapiIe->IeHeader.Length += sizeof( tANI_U16 );
if(fBKIDFound)
{
pWapiIe->IeHeader.Length += CSR_WAPI_BKID_SIZE;
}
// return the size of the IE header (total) constructed...
cbWapiIe = pWapiIe->IeHeader.Length + sizeof( pWapiIe->IeHeader );
} while( 0 );
if( !pIes && pIesLocal )
{
//locally allocated
palFreeMemory(pMac->hHdd, pIesLocal);
}
return( cbWapiIe );
}
#endif /* FEATURE_WLAN_WAPI */
tANI_BOOLEAN csrGetWpaCyphers( tpAniSirGlobal pMac, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
tDot11fIEWPA *pWpaIe,
tANI_U8 *UnicastCypher,
tANI_U8 *MulticastCypher,
tANI_U8 *AuthSuite,
eCsrAuthType *pNegotiatedAuthtype,
eCsrEncryptionType *pNegotiatedMCCipher )
{
tANI_BOOLEAN fAcceptableCyphers = FALSE;
tANI_U8 cUnicastCyphers = 0;
tANI_U8 cMulticastCyphers = 0;
tANI_U8 cAuthSuites = 0;
tANI_U8 Unicast[ CSR_WPA_OUI_SIZE ];
tANI_U8 Multicast[ CSR_WPA_OUI_SIZE ];
tANI_U8 Authentication[ CSR_WPA_OUI_SIZE ];
tANI_U8 MulticastCyphers[ 1 ][ CSR_WPA_OUI_SIZE ];
tANI_U8 i;
eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
do
{
if ( pWpaIe->present )
{
cMulticastCyphers = 1;
palCopyMemory(pMac->hHdd, MulticastCyphers, pWpaIe->multicast_cipher, CSR_WPA_OUI_SIZE);
cUnicastCyphers = (tANI_U8)(pWpaIe->unicast_cipher_count);
cAuthSuites = (tANI_U8)(pWpaIe->auth_suite_count);
//Check - Is requested Unicast Cipher supported by the BSS.
fAcceptableCyphers = csrMatchWPAOUIIndex( pMac, pWpaIe->unicast_ciphers, cUnicastCyphers,
csrGetOUIIndexFromCipher( enType ), Unicast );
if( !fAcceptableCyphers ) break;
//Unicast is supported. Pick the first matching Group cipher, if any.
for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
{
fAcceptableCyphers = csrMatchWPAOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i]), Multicast );
if(fAcceptableCyphers)
{
break;
}
}
if( !fAcceptableCyphers ) break;
if( pNegotiatedMCCipher )
*pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
/* Initializing with FALSE as it has TRUE value already */
fAcceptableCyphers = FALSE;
for (i = 0 ; i < pAuthType->numEntries; i++)
{
//Ciphers are supported, Match authentication algorithm and pick first matching authtype.
if ( csrIsAuthWpa( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_WPA == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_WPA;
}
if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthWpaPsk( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_WPA_PSK == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_WPA_PSK;
}
#ifdef FEATURE_WLAN_CCX
if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsCcxCckmAuthWpa( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
{
if (eCSR_AUTH_TYPE_CCKM_WPA == pAuthType->authType[i])
negAuthType = eCSR_AUTH_TYPE_CCKM_WPA;
}
#endif /* FEATURE_WLAN_CCX */
// The 1st auth type in the APs WPA IE, to match stations connecting
// profiles auth type will cause us to exit this loop
// This is added as some APs advertise multiple akms in the WPA IE.
if (eCSR_AUTH_TYPE_UNKNOWN != negAuthType)
{
fAcceptableCyphers = TRUE;
break;
}
} // for
}
}while(0);
if ( fAcceptableCyphers )
{
if ( MulticastCypher )
{
palCopyMemory( pMac->hHdd, (tANI_U8 **)MulticastCypher, Multicast, CSR_WPA_OUI_SIZE );
}
if ( UnicastCypher )
{
palCopyMemory( pMac->hHdd, (tANI_U8 **)UnicastCypher, Unicast, CSR_WPA_OUI_SIZE );
}
if ( AuthSuite )
{
palCopyMemory( pMac->hHdd, (tANI_U8 **)AuthSuite, Authentication, CSR_WPA_OUI_SIZE );
}
if( pNegotiatedAuthtype )
{
*pNegotiatedAuthtype = negAuthType;
}
}
return( fAcceptableCyphers );
}
tANI_BOOLEAN csrIsWpaEncryptionMatch( tpAniSirGlobal pMac, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthtype, eCsrEncryptionType *pNegotiatedMCCipher )
{
tANI_BOOLEAN fWpaMatch = eANI_BOOLEAN_FALSE;
// See if the cyphers in the Bss description match with the settings in the profile.
fWpaMatch = csrGetWpaCyphers( pMac, pAuthType, enType, pEnMcType, &pIes->WPA, NULL, NULL, NULL, pNegotiatedAuthtype, pNegotiatedMCCipher );
return( fWpaMatch );
}
tANI_U8 csrConstructWpaIe( tHalHandle hHal, tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
tDot11fBeaconIEs *pIes, tCsrWpaIe *pWpaIe )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fWpaMatch;
tANI_U8 cbWpaIe = 0;
tANI_U8 UnicastCypher[ CSR_WPA_OUI_SIZE ];
tANI_U8 MulticastCypher[ CSR_WPA_OUI_SIZE ];
tANI_U8 AuthSuite[ CSR_WPA_OUI_SIZE ];
tCsrWpaAuthIe *pAuthSuite;
tDot11fBeaconIEs *pIesLocal = pIes;
do
{
if ( !csrIsProfileWpa( pProfile ) ) break;
if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
{
break;
}
// See if the cyphers in the Bss description match with the settings in the profile.
fWpaMatch = csrGetWpaCyphers( hHal, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType, &pProfile->mcEncryptionType,
&pIesLocal->WPA, UnicastCypher, MulticastCypher, AuthSuite, NULL, NULL );
if ( !fWpaMatch ) break;
pWpaIe->IeHeader.ElementID = SIR_MAC_WPA_EID;
palCopyMemory( pMac->hHdd, pWpaIe->Oui, csrWpaOui[01], sizeof( pWpaIe->Oui ) );
pWpaIe->Version = CSR_WPA_VERSION_SUPPORTED;
palCopyMemory( pMac->hHdd, pWpaIe->MulticastOui, MulticastCypher, sizeof( MulticastCypher ) );
pWpaIe->cUnicastCyphers = 1;
palCopyMemory( pMac->hHdd, &pWpaIe->UnicastOui[ 0 ], UnicastCypher, sizeof( UnicastCypher ) );
pAuthSuite = (tCsrWpaAuthIe *)( &pWpaIe->UnicastOui[ pWpaIe->cUnicastCyphers ] );
pAuthSuite->cAuthenticationSuites = 1;
palCopyMemory( pMac->hHdd, &pAuthSuite->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
// The WPA capabilities follows the Auth Suite (two octects)--
// this field is optional, and we always "send" zero, so just
// remove it. This is consistent with our assumptions in the
// frames compiler; c.f. bug 15234:
// http://gold.woodsidenet.com/bugzilla/show_bug.cgi?id=15234
// Add in the fixed fields plus 1 Unicast cypher, less the IE Header length
// Add in the size of the Auth suite (count plus a single OUI)
pWpaIe->IeHeader.Length = sizeof( *pWpaIe ) - sizeof ( pWpaIe->IeHeader ) +
sizeof( *pAuthSuite );
// return the size of the IE header (total) constructed...
cbWpaIe = pWpaIe->IeHeader.Length + sizeof( pWpaIe->IeHeader );
} while( 0 );
if( !pIes && pIesLocal )
{
//locally allocated
palFreeMemory(pMac->hHdd, pIesLocal);
}
return( cbWpaIe );
}
tANI_BOOLEAN csrGetWpaRsnIe( tHalHandle hHal, tANI_U8 *pIes, tANI_U32 len,
tANI_U8 *pWpaIe, tANI_U8 *pcbWpaIe, tANI_U8 *pRSNIe, tANI_U8 *pcbRSNIe)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tDot11IEHeader *pIEHeader;
tSirMacPropIE *pSirMacPropIE;
tANI_U32 cbParsed;
tANI_U32 cbIE;
int cExpectedIEs = 0;
int cFoundIEs = 0;
int cbPropIETotal;
pIEHeader = (tDot11IEHeader *)pIes;
if(pWpaIe) cExpectedIEs++;
if(pRSNIe) cExpectedIEs++;
// bss description length includes all fields other than the length itself
cbParsed = 0;
// Loop as long as there is data left in the IE of the Bss Description
// and the number of Expected IEs is NOT found yet.
while( ( (cbParsed + sizeof( *pIEHeader )) <= len ) && ( cFoundIEs < cExpectedIEs ) )
{
cbIE = sizeof( *pIEHeader ) + pIEHeader->Length;
if ( ( cbIE + cbParsed ) > len ) break;
if ( ( pIEHeader->Length >= gCsrIELengthTable[ pIEHeader->ElementID ].min ) &&
( pIEHeader->Length <= gCsrIELengthTable[ pIEHeader->ElementID ].max ) )
{
switch( pIEHeader->ElementID )
{
// Parse the 221 (0xdd) Proprietary IEs here...
// Note that the 221 IE is overloaded, containing the WPA IE, WMM/WME IE, and the
// Airgo proprietary IE information.
case SIR_MAC_WPA_EID:
{
tANI_U32 aniOUI;
tANI_U8 *pOui = (tANI_U8 *)&aniOUI;
pOui++;
aniOUI = ANI_OUI;
aniOUI = i_ntohl( aniOUI );
pSirMacPropIE = ( tSirMacPropIE *)pIEHeader;
cbPropIETotal = pSirMacPropIE->length;
// Validate the ANI OUI is in the OUI field in the proprietary IE...
if ( ( pSirMacPropIE->length >= WNI_CFG_MANUFACTURER_OUI_LEN ) &&
pOui[ 0 ] == pSirMacPropIE->oui[ 0 ] &&
pOui[ 1 ] == pSirMacPropIE->oui[ 1 ] &&
pOui[ 2 ] == pSirMacPropIE->oui[ 2 ] )
{
}
else
{
tCsrWpaIe *pIe = ( tCsrWpaIe * )pIEHeader;
if(!pWpaIe || !pcbWpaIe) break;
// Check if this is a valid WPA IE. Then check that the
// WPA OUI is in place and the version is one that we support.
if ( ( pIe->IeHeader.Length >= SIR_MAC_WPA_IE_MIN_LENGTH ) &&
( palEqualMemory(pMac->hHdd, pIe->Oui, (void *)csrWpaOui[1], sizeof( pIe->Oui ) ) ) &&
( pIe->Version <= CSR_WPA_VERSION_SUPPORTED ) )
{
palCopyMemory(pMac->hHdd, pWpaIe, pIe, pIe->IeHeader.Length + sizeof( pIe->IeHeader ) );
*pcbWpaIe = pIe->IeHeader.Length + sizeof( pIe->IeHeader );
cFoundIEs++;
break;
}
}
break;
}
case SIR_MAC_RSN_EID:
{
tCsrRSNIe *pIe;
if(!pcbRSNIe || !pRSNIe) break;
pIe = (tCsrRSNIe *)pIEHeader;
// Check the length of the RSN Ie to assure it is valid. Then check that the
// version is one that we support.
if ( pIe->IeHeader.Length < SIR_MAC_RSN_IE_MIN_LENGTH ) break;
if ( pIe->Version > CSR_RSN_VERSION_SUPPORTED ) break;
cFoundIEs++;
// if there is enough room in the WpaIE passed in, then copy the Wpa IE into
// the buffer passed in.
if ( *pcbRSNIe < pIe->IeHeader.Length + sizeof( pIe->IeHeader ) ) break;
palCopyMemory(pMac->hHdd, pRSNIe, pIe, pIe->IeHeader.Length + sizeof( pIe->IeHeader ) );
*pcbRSNIe = pIe->IeHeader.Length + sizeof( pIe->IeHeader );
break;
}
// Add support for other IE here...
default:
break;
}
}
cbParsed += cbIE;
pIEHeader = (tDot11IEHeader *)( ((tANI_U8 *)pIEHeader) + cbIE );
}
// return a BOOL that tells if all of the IEs asked for were found...
return( cFoundIEs == cExpectedIEs );
}
//If a WPAIE exists in the profile, just use it. Or else construct one from the BSS
//Caller allocated memory for pWpaIe and guarrantee it can contain a max length WPA IE
tANI_U8 csrRetrieveWpaIe( tHalHandle hHal, tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
tDot11fBeaconIEs *pIes, tCsrWpaIe *pWpaIe )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_U8 cbWpaIe = 0;
do
{
if ( !csrIsProfileWpa( pProfile ) ) break;
if(pProfile->nWPAReqIELength && pProfile->pWPAReqIE)
{
if(SIR_MAC_WPA_IE_MAX_LENGTH >= pProfile->nWPAReqIELength)
{
cbWpaIe = (tANI_U8)pProfile->nWPAReqIELength;
palCopyMemory(pMac->hHdd, pWpaIe, pProfile->pWPAReqIE, cbWpaIe);
}
else
{
smsLog(pMac, LOGW, " csrRetrieveWpaIe detect invalid WPA IE length (%d) ", pProfile->nWPAReqIELength);
}
}
else
{
cbWpaIe = csrConstructWpaIe(pMac, pProfile, pSirBssDesc, pIes, pWpaIe);
}
}while(0);
return (cbWpaIe);
}
//If a RSNIE exists in the profile, just use it. Or else construct one from the BSS
//Caller allocated memory for pWpaIe and guarrantee it can contain a max length WPA IE
tANI_U8 csrRetrieveRsnIe( tHalHandle hHal, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrRSNIe *pRsnIe )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_U8 cbRsnIe = 0;
do
{
if ( !csrIsProfileRSN( pProfile ) ) break;
#ifdef FEATURE_WLAN_LFR
if (csrRoamIsFastRoamEnabled(pMac, sessionId))
{
// If "Legacy Fast Roaming" is enabled ALWAYS rebuild the RSN IE from
// scratch. So it contains the current PMK-IDs
cbRsnIe = csrConstructRSNIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pRsnIe);
}
else
#endif
if(pProfile->nRSNReqIELength && pProfile->pRSNReqIE)
{
// If you have one started away, re-use it.
if(SIR_MAC_WPA_IE_MAX_LENGTH >= pProfile->nRSNReqIELength)
{
cbRsnIe = (tANI_U8)pProfile->nRSNReqIELength;
palCopyMemory(pMac->hHdd, pRsnIe, pProfile->pRSNReqIE, cbRsnIe);
}
else
{
smsLog(pMac, LOGW, " csrRetrieveRsnIe detect invalid RSN IE length (%d) ", pProfile->nRSNReqIELength);
}
}
else
{
cbRsnIe = csrConstructRSNIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pRsnIe);
}
}while(0);
return (cbRsnIe);
}
#ifdef FEATURE_WLAN_WAPI
//If a WAPI IE exists in the profile, just use it. Or else construct one from the BSS
//Caller allocated memory for pWapiIe and guarrantee it can contain a max length WAPI IE
tANI_U8 csrRetrieveWapiIe( tHalHandle hHal, tANI_U32 sessionId,
tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
tDot11fBeaconIEs *pIes, tCsrWapiIe *pWapiIe )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_U8 cbWapiIe = 0;
do
{
if ( !csrIsProfileWapi( pProfile ) ) break;
if(pProfile->nWAPIReqIELength && pProfile->pWAPIReqIE)
{
if(DOT11F_IE_WAPI_MAX_LEN >= pProfile->nWAPIReqIELength)
{
cbWapiIe = (tANI_U8)pProfile->nWAPIReqIELength;
palCopyMemory(pMac->hHdd, pWapiIe, pProfile->pWAPIReqIE, cbWapiIe);
}
else
{
smsLog(pMac, LOGW, " csrRetrieveWapiIe detect invalid WAPI IE length (%d) ", pProfile->nWAPIReqIELength);
}
}
else
{
cbWapiIe = csrConstructWapiIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pWapiIe);
}
}while(0);
return (cbWapiIe);
}
#endif /* FEATURE_WLAN_WAPI */
tANI_BOOLEAN csrSearchChannelListForTxPower(tHalHandle hHal, tSirBssDescription *pBssDescription, tCsrChannelSet *returnChannelGroup)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tListElem *pEntry;
tANI_U16 i;
tANI_U16 startingChannel;
tANI_BOOLEAN found = FALSE;
tCsrChannelSet *pChannelGroup;
pEntry = csrLLPeekHead( &pMac->roam.channelList5G, LL_ACCESS_LOCK );
while ( pEntry )
{
pChannelGroup = GET_BASE_ADDR( pEntry, tCsrChannelSet, channelListLink );
startingChannel = pChannelGroup->firstChannel;
for ( i = 0; i < pChannelGroup->numChannels; i++ )
{
if ( startingChannel + i * pChannelGroup->interChannelOffset == pBssDescription->channelId )
{
found = TRUE;
break;
}
}
if ( found )
{
palCopyMemory(pMac->hHdd, returnChannelGroup, pChannelGroup, sizeof(tCsrChannelSet));
break;
}
else
{
pEntry = csrLLNext( &pMac->roam.channelList5G, pEntry, LL_ACCESS_LOCK );
}
}
return( found );
}
tANI_BOOLEAN csrRatesIsDot11Rate11bSupportedRate( tANI_U8 dot11Rate )
{
tANI_BOOLEAN fSupported = FALSE;
tANI_U16 nonBasicRate = (tANI_U16)( BITS_OFF( dot11Rate, CSR_DOT11_BASIC_RATE_MASK ) );
switch ( nonBasicRate )
{
case eCsrSuppRate_1Mbps:
case eCsrSuppRate_2Mbps:
case eCsrSuppRate_5_5Mbps:
case eCsrSuppRate_11Mbps:
fSupported = TRUE;
break;
default:
break;
}
return( fSupported );
}
tANI_BOOLEAN csrRatesIsDot11Rate11aSupportedRate( tANI_U8 dot11Rate )
{
tANI_BOOLEAN fSupported = FALSE;
tANI_U16 nonBasicRate = (tANI_U16)( BITS_OFF( dot11Rate, CSR_DOT11_BASIC_RATE_MASK ) );
switch ( nonBasicRate )
{
case eCsrSuppRate_6Mbps:
case eCsrSuppRate_9Mbps:
case eCsrSuppRate_12Mbps:
case eCsrSuppRate_18Mbps:
case eCsrSuppRate_24Mbps:
case eCsrSuppRate_36Mbps:
case eCsrSuppRate_48Mbps:
case eCsrSuppRate_54Mbps:
fSupported = TRUE;
break;
default:
break;
}
return( fSupported );
}
tAniEdType csrTranslateEncryptTypeToEdType( eCsrEncryptionType EncryptType )
{
tAniEdType edType;
switch ( EncryptType )
{
default:
case eCSR_ENCRYPT_TYPE_NONE:
edType = eSIR_ED_NONE;
break;
case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
case eCSR_ENCRYPT_TYPE_WEP40:
edType = eSIR_ED_WEP40;
break;
case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
case eCSR_ENCRYPT_TYPE_WEP104:
edType = eSIR_ED_WEP104;
break;
case eCSR_ENCRYPT_TYPE_TKIP:
edType = eSIR_ED_TKIP;
break;
case eCSR_ENCRYPT_TYPE_AES:
edType = eSIR_ED_CCMP;
break;
#ifdef FEATURE_WLAN_WAPI
case eCSR_ENCRYPT_TYPE_WPI:
edType = eSIR_ED_WPI;
#endif
#ifdef WLAN_FEATURE_11W
//11w BIP
case eCSR_ENCRYPT_TYPE_AES_CMAC:
edType = eSIR_ED_AES_128_CMAC;
break;
#endif
}
return( edType );
}
//pIes can be NULL
tANI_BOOLEAN csrValidateWep( tpAniSirGlobal pMac, eCsrEncryptionType ucEncryptionType,
tCsrAuthList *pAuthList, tCsrEncryptionList *pMCEncryptionList,
eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCEncryption,
tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes )
{
tANI_U32 idx;
tANI_BOOLEAN fMatch = FALSE;
eCsrAuthType negotiatedAuth = eCSR_AUTH_TYPE_OPEN_SYSTEM;
eCsrEncryptionType negotiatedMCCipher = eCSR_ENCRYPT_TYPE_UNKNOWN;
//This function just checks whether HDD is giving correct values for Multicast cipher and Auth.
do
{
//If privacy bit is not set, consider no match
if ( !csrIsPrivacy( pSirBssDesc ) ) break;
for( idx = 0; idx < pMCEncryptionList->numEntries; idx++ )
{
switch( pMCEncryptionList->encryptionType[idx] )
{
case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
case eCSR_ENCRYPT_TYPE_WEP40:
case eCSR_ENCRYPT_TYPE_WEP104:
/* Multicast list may contain WEP40/WEP104. Check whether it matches UC.
*/
if( ucEncryptionType == pMCEncryptionList->encryptionType[idx] )
{
fMatch = TRUE;
negotiatedMCCipher = pMCEncryptionList->encryptionType[idx];
}
break;
default:
fMatch = FALSE;
break;
}
if(fMatch) break;
}
if(!fMatch) break;
for( idx = 0; idx < pAuthList->numEntries; idx++ )
{
switch( pAuthList->authType[idx] )
{
case eCSR_AUTH_TYPE_OPEN_SYSTEM:
case eCSR_AUTH_TYPE_SHARED_KEY:
case eCSR_AUTH_TYPE_AUTOSWITCH:
fMatch = TRUE;
negotiatedAuth = pAuthList->authType[idx];
break;
default:
fMatch = FALSE;
}
if (fMatch) break;
}
if(!fMatch) break;
//In case of WPA / WPA2, check whether it supports WEP as well
if(pIes)
{
//Prepare the encryption type for WPA/WPA2 functions
if( eCSR_ENCRYPT_TYPE_WEP40_STATICKEY == ucEncryptionType )
{
ucEncryptionType = eCSR_ENCRYPT_TYPE_WEP40;
}
else if( eCSR_ENCRYPT_TYPE_WEP104 == ucEncryptionType )
{
ucEncryptionType = eCSR_ENCRYPT_TYPE_WEP104;
}
//else we can use the encryption type directly
if( pIes->WPA.present )
{
fMatch = palEqualMemory(pMac->hHdd, pIes->WPA.multicast_cipher,
csrWpaOui[csrGetOUIIndexFromCipher( ucEncryptionType )], CSR_WPA_OUI_SIZE );
if( fMatch ) break;
}
if( pIes->RSN.present )
{
fMatch = palEqualMemory(pMac->hHdd, pIes->RSN.gp_cipher_suite,
csrRSNOui[csrGetOUIIndexFromCipher( ucEncryptionType )], CSR_RSN_OUI_SIZE );
}
}
}while(0);
if( fMatch )
{
if( pNegotiatedAuthType )
*pNegotiatedAuthType = negotiatedAuth;
if( pNegotiatedMCEncryption )
*pNegotiatedMCEncryption = negotiatedMCCipher;
}
return fMatch;
}
//pIes shall contain IEs from pSirBssDesc. It shall be returned from function csrGetParsedBssDescriptionIEs
tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType, tCsrEncryptionList *pUCEncryptionType, tCsrEncryptionList *pMCEncryptionType,
tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes,
eCsrAuthType *negotiatedAuthtype, eCsrEncryptionType *negotiatedUCCipher, eCsrEncryptionType *negotiatedMCCipher )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fMatch = FALSE;
tANI_U8 i,idx;
eCsrEncryptionType mcCipher = eCSR_ENCRYPT_TYPE_UNKNOWN, ucCipher = eCSR_ENCRYPT_TYPE_UNKNOWN;
eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
for( i = 0 ; ((i < pUCEncryptionType->numEntries) && (!fMatch)) ; i++ )
{
ucCipher = pUCEncryptionType->encryptionType[i];
// If the Bss description shows the Privacy bit is on, then we must have some sort of encryption configured
// for the profile to work. Don't attempt to join networks with Privacy bit set when profiles say NONE for
// encryption type.
switch ( ucCipher )
{
case eCSR_ENCRYPT_TYPE_NONE:
{
// for NO encryption, if the Bss description has the Privacy bit turned on, then encryption is
// required so we have to reject this Bss.
if ( csrIsPrivacy( pSirBssDesc ) )
{
fMatch = FALSE;
}
else
{
fMatch = TRUE;
}
if ( fMatch )
{
fMatch = FALSE;
//Check Multicast cipher requested and Auth type requested.
for( idx = 0 ; idx < pMCEncryptionType->numEntries ; idx++ )
{
if( eCSR_ENCRYPT_TYPE_NONE == pMCEncryptionType->encryptionType[idx] )
{
fMatch = TRUE; //Multicast can only be none.
mcCipher = pMCEncryptionType->encryptionType[idx];
break;
}
}
if (!fMatch) break;
fMatch = FALSE;
//Check Auth list. It should contain AuthOpen.
for( idx = 0 ; idx < authType->numEntries ; idx++ )
{
if(( eCSR_AUTH_TYPE_OPEN_SYSTEM == authType->authType[idx] ) ||
( eCSR_AUTH_TYPE_AUTOSWITCH == authType->authType[idx] ))
{
fMatch = TRUE;
negAuthType = eCSR_AUTH_TYPE_OPEN_SYSTEM;
break;
}
}
if (!fMatch) break;
}
break;
}
case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
// !! might want to check for WEP keys set in the Profile.... ?
// !! don't need to have the privacy bit in the Bss description. Many AP policies make legacy
// encryption 'optional' so we don't know if we can associate or not. The AP will reject if
// encryption is not allowed without the Privacy bit turned on.
fMatch = csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes);
break;
// these are all of the WPA encryption types...
case eCSR_ENCRYPT_TYPE_WEP40:
case eCSR_ENCRYPT_TYPE_WEP104:
fMatch = csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes);
break;
case eCSR_ENCRYPT_TYPE_TKIP:
case eCSR_ENCRYPT_TYPE_AES:
{
if(pIes)
{
// First check if there is a RSN match
fMatch = csrIsRSNMatch( pMac, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
if( !fMatch )
{
// If not RSN, then check if there is a WPA match
fMatch = csrIsWpaEncryptionMatch( pMac, authType, ucCipher, pMCEncryptionType, pIes,
&negAuthType, &mcCipher );
}
}
else
{
fMatch = FALSE;
}
break;
}
#ifdef FEATURE_WLAN_WAPI
case eCSR_ENCRYPT_TYPE_WPI://WAPI
{
if(pIes)
{
fMatch = csrIsWapiMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
}
else
{
fMatch = FALSE;
}
break;
}
#endif /* FEATURE_WLAN_WAPI */
case eCSR_ENCRYPT_TYPE_ANY:
default:
{
tANI_BOOLEAN fMatchAny = eANI_BOOLEAN_FALSE;
fMatch = eANI_BOOLEAN_TRUE;
//It is allowed to match anything. Try the more secured ones first.
if(pIes)
{
//Check AES first
ucCipher = eCSR_ENCRYPT_TYPE_AES;
fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
if(!fMatchAny)
{
//Check TKIP
ucCipher = eCSR_ENCRYPT_TYPE_TKIP;
fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
}
#ifdef FEATURE_WLAN_WAPI
if(!fMatchAny)
{
//Check WAPI
ucCipher = eCSR_ENCRYPT_TYPE_WPI;
fMatchAny = csrIsWapiMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
}
#endif /* FEATURE_WLAN_WAPI */
}
if(!fMatchAny)
{
ucCipher = eCSR_ENCRYPT_TYPE_WEP104;
if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
{
ucCipher = eCSR_ENCRYPT_TYPE_WEP40;
if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
{
ucCipher = eCSR_ENCRYPT_TYPE_WEP104_STATICKEY;
if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
{
ucCipher = eCSR_ENCRYPT_TYPE_WEP40_STATICKEY;
if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
{
//It must be open and no encryption
if ( csrIsPrivacy( pSirBssDesc ) )
{
//This is not right
fMatch = eANI_BOOLEAN_FALSE;
}
else
{
negAuthType = eCSR_AUTH_TYPE_OPEN_SYSTEM;
mcCipher = eCSR_ENCRYPT_TYPE_NONE;
ucCipher = eCSR_ENCRYPT_TYPE_NONE;
}
}
}
}
}
}
break;
}
}
}
if( fMatch )
{
if( negotiatedUCCipher )
*negotiatedUCCipher = ucCipher;
if( negotiatedMCCipher )
*negotiatedMCCipher = mcCipher;
if( negotiatedAuthtype )
*negotiatedAuthtype = negAuthType;
}
return( fMatch );
}
tANI_BOOLEAN csrIsSsidMatch( tpAniSirGlobal pMac, tANI_U8 *ssid1, tANI_U8 ssid1Len, tANI_U8 *bssSsid,
tANI_U8 bssSsidLen, tANI_BOOLEAN fSsidRequired )
{
tANI_BOOLEAN fMatch = FALSE;
do {
// There are a few special cases. If the Bss description has a Broadcast SSID,
// then our Profile must have a single SSID without Wildcards so we can program
// the SSID.
// SSID could be suppressed in beacons. In that case SSID IE has valid length
// but the SSID value is all NULL characters. That condition is trated same
// as NULL SSID
if ( csrIsNULLSSID( bssSsid, bssSsidLen ) )
{
if ( eANI_BOOLEAN_FALSE == fSsidRequired )
{
fMatch = TRUE;
}
break;
}
// Check for the specification of the Broadcast SSID at the beginning of the list.
// If specified, then all SSIDs are matches (broadcast SSID means accept all SSIDs).
if ( ssid1Len == 0 )
{
fMatch = TRUE;
break;
}
if(ssid1Len != bssSsidLen) break;
if(palEqualMemory(pMac->hHdd, bssSsid, ssid1, bssSsidLen))
{
fMatch = TRUE;
break;
}
} while( 0 );
return( fMatch );
}
//Null ssid means match
tANI_BOOLEAN csrIsSsidInList( tHalHandle hHal, tSirMacSSid *pSsid, tCsrSSIDs *pSsidList )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fMatch = FALSE;
tANI_U32 i;
if ( pSsidList && pSsid )
{
for(i = 0; i < pSsidList->numOfSSIDs; i++)
{
if(csrIsNULLSSID(pSsidList->SSIDList[i].SSID.ssId, pSsidList->SSIDList[i].SSID.length) ||
((pSsidList->SSIDList[i].SSID.length == pSsid->length) &&
palEqualMemory(pMac->hHdd, pSsid->ssId, pSsidList->SSIDList[i].SSID.ssId, pSsid->length)))
{
fMatch = TRUE;
break;
}
}
}
return (fMatch);
}
//like to use sirCompareMacAddr
tANI_BOOLEAN csrIsMacAddressZero( tpAniSirGlobal pMac, tCsrBssid *pMacAddr )
{
tANI_U8 bssid[WNI_CFG_BSSID_LEN] = {0, 0, 0, 0, 0, 0};
return( palEqualMemory(pMac->hHdd, bssid, pMacAddr, WNI_CFG_BSSID_LEN));
}
//like to use sirCompareMacAddr
tANI_BOOLEAN csrIsMacAddressBroadcast( tpAniSirGlobal pMac, tCsrBssid *pMacAddr )
{
tANI_U8 bssid[WNI_CFG_BSSID_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
return( palEqualMemory(pMac->hHdd, bssid, pMacAddr, WNI_CFG_BSSID_LEN));
}
//like to use sirCompareMacAddr
tANI_BOOLEAN csrIsMacAddressEqual( tpAniSirGlobal pMac, tCsrBssid *pMacAddr1, tCsrBssid *pMacAddr2 )
{
return( palEqualMemory(pMac->hHdd, pMacAddr1, pMacAddr2, sizeof(tCsrBssid)) );
}
tANI_BOOLEAN csrIsBssidMatch( tHalHandle hHal, tCsrBssid *pProfBssid, tCsrBssid *BssBssid )
{
tANI_BOOLEAN fMatch = FALSE;
tCsrBssid ProfileBssid;
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
// for efficiency of the MAC_ADDRESS functions, move the
// Bssid's into MAC_ADDRESS structs.
palCopyMemory( pMac->hHdd, &ProfileBssid, pProfBssid, sizeof(tCsrBssid) );
do {
// Give the profile the benefit of the doubt... accept either all 0 or
// the real broadcast Bssid (all 0xff) as broadcast Bssids (meaning to
// match any Bssids).
if ( csrIsMacAddressZero( pMac, &ProfileBssid ) ||
csrIsMacAddressBroadcast( pMac, &ProfileBssid ) )
{
fMatch = TRUE;
break;
}
if ( csrIsMacAddressEqual( pMac, BssBssid, &ProfileBssid ) )
{
fMatch = TRUE;
break;
}
} while( 0 );
return( fMatch );
}
tANI_BOOLEAN csrIsBSSTypeMatch(eCsrRoamBssType bssType1, eCsrRoamBssType bssType2)
{
if((eCSR_BSS_TYPE_ANY != bssType1 && eCSR_BSS_TYPE_ANY != bssType2) && (bssType1 != bssType2))
return eANI_BOOLEAN_FALSE;
else
return eANI_BOOLEAN_TRUE;
}
tANI_BOOLEAN csrIsBssTypeIBSS(eCsrRoamBssType bssType)
{
return((tANI_BOOLEAN)(eCSR_BSS_TYPE_START_IBSS == bssType || eCSR_BSS_TYPE_IBSS == bssType));
}
tANI_BOOLEAN csrIsBssTypeWDS(eCsrRoamBssType bssType)
{
return((tANI_BOOLEAN)(eCSR_BSS_TYPE_WDS_STA == bssType || eCSR_BSS_TYPE_WDS_AP == bssType));
}
tANI_BOOLEAN csrIsBSSTypeCapsMatch( eCsrRoamBssType bssType, tSirBssDescription *pSirBssDesc )
{
tANI_BOOLEAN fMatch = TRUE;
do
{
switch( bssType )
{
case eCSR_BSS_TYPE_ANY:
break;
case eCSR_BSS_TYPE_INFRASTRUCTURE:
case eCSR_BSS_TYPE_WDS_STA:
if( !csrIsInfraBssDesc( pSirBssDesc ) )
fMatch = FALSE;
break;
case eCSR_BSS_TYPE_IBSS:
case eCSR_BSS_TYPE_START_IBSS:
if( !csrIsIbssBssDesc( pSirBssDesc ) )
fMatch = FALSE;
break;
case eCSR_BSS_TYPE_WDS_AP: //For WDS AP, no need to match anything
default:
fMatch = FALSE;
break;
}
}
while( 0 );
return( fMatch );
}
static tANI_BOOLEAN csrIsCapabilitiesMatch( tpAniSirGlobal pMac, eCsrRoamBssType bssType, tSirBssDescription *pSirBssDesc )
{
return( csrIsBSSTypeCapsMatch( bssType, pSirBssDesc ) );
}
static tANI_BOOLEAN csrIsSpecificChannelMatch( tpAniSirGlobal pMac, tSirBssDescription *pSirBssDesc, tANI_U8 Channel )
{
tANI_BOOLEAN fMatch = TRUE;
do
{
// if the channel is ANY, then always match...
if ( eCSR_OPERATING_CHANNEL_ANY == Channel ) break;
if ( Channel == pSirBssDesc->channelId ) break;
// didn't match anything.. so return NO match
fMatch = FALSE;
} while( 0 );
return( fMatch );
}
tANI_BOOLEAN csrIsChannelBandMatch( tpAniSirGlobal pMac, tANI_U8 channelId, tSirBssDescription *pSirBssDesc )
{
tANI_BOOLEAN fMatch = TRUE;
do
{
// if the profile says Any channel AND the global settings says ANY channel, then we
// always match...
if ( eCSR_OPERATING_CHANNEL_ANY == channelId ) break;
if ( eCSR_OPERATING_CHANNEL_ANY != channelId )
{
fMatch = csrIsSpecificChannelMatch( pMac, pSirBssDesc, channelId );
}
} while( 0 );
return( fMatch );
}
/**
* \brief Enquire as to whether a given rate is supported by the
* adapter as currently configured
*
*
* \param nRate A rate in units of 500kbps
*
* \return TRUE if the adapter is currently capable of supporting this
* rate, FALSE else
*
*
* The rate encoding is just as in 802.11 Information Elements, except
* that the high bit is \em not interpreted as indicating a Basic Rate,
* and proprietary rates are allowed, too.
*
* Note that if the adapter's dot11Mode is g, we don't restrict the
* rates. According to hwReadEepromParameters, this will happen when:
*
* ... the card is configured for ALL bands through the property
* page. If this occurs, and the card is not an ABG card ,then this
* code is setting the dot11Mode to assume the mode that the
* hardware can support. For example, if the card is an 11BG card
* and we are configured to support ALL bands, then we change the
* dot11Mode to 11g because ALL in this case is only what the
* hardware can support.
*
*
*/
static tANI_BOOLEAN csrIsAggregateRateSupported( tpAniSirGlobal pMac, tANI_U16 rate )
{
tANI_BOOLEAN fSupported = eANI_BOOLEAN_FALSE;
tANI_U16 idx, newRate;
//In case basic rate flag is set
newRate = BITS_OFF(rate, CSR_DOT11_BASIC_RATE_MASK);
if ( eCSR_CFG_DOT11_MODE_11A == pMac->roam.configParam.uCfgDot11Mode )
{
switch ( newRate )
{
case eCsrSuppRate_6Mbps:
case eCsrSuppRate_9Mbps:
case eCsrSuppRate_12Mbps:
case eCsrSuppRate_18Mbps:
case eCsrSuppRate_24Mbps:
case eCsrSuppRate_36Mbps:
case eCsrSuppRate_48Mbps:
case eCsrSuppRate_54Mbps:
fSupported = TRUE;
break;
default:
fSupported = FALSE;
break;
}
}
else if( eCSR_CFG_DOT11_MODE_11B == pMac->roam.configParam.uCfgDot11Mode )
{
switch ( newRate )
{
case eCsrSuppRate_1Mbps:
case eCsrSuppRate_2Mbps:
case eCsrSuppRate_5_5Mbps:
case eCsrSuppRate_11Mbps:
fSupported = TRUE;
break;
default:
fSupported = FALSE;
break;
}
}
else if ( !pMac->roam.configParam.ProprietaryRatesEnabled )
{
switch ( newRate )
{
case eCsrSuppRate_1Mbps:
case eCsrSuppRate_2Mbps:
case eCsrSuppRate_5_5Mbps:
case eCsrSuppRate_6Mbps:
case eCsrSuppRate_9Mbps:
case eCsrSuppRate_11Mbps:
case eCsrSuppRate_12Mbps:
case eCsrSuppRate_18Mbps:
case eCsrSuppRate_24Mbps:
case eCsrSuppRate_36Mbps:
case eCsrSuppRate_48Mbps:
case eCsrSuppRate_54Mbps:
fSupported = TRUE;
break;
default:
fSupported = FALSE;
break;
}
}
else {
if ( eCsrSuppRate_1Mbps == newRate ||
eCsrSuppRate_2Mbps == newRate ||
eCsrSuppRate_5_5Mbps == newRate ||
eCsrSuppRate_11Mbps == newRate )
{
fSupported = TRUE;
}
else {
idx = 0x1;
switch ( newRate )
{
case eCsrSuppRate_6Mbps:
fSupported = gPhyRatesSuppt[0][idx];
break;
case eCsrSuppRate_9Mbps:
fSupported = gPhyRatesSuppt[1][idx];
break;
case eCsrSuppRate_12Mbps:
fSupported = gPhyRatesSuppt[2][idx];
break;
case eCsrSuppRate_18Mbps:
fSupported = gPhyRatesSuppt[3][idx];
break;
case eCsrSuppRate_20Mbps:
fSupported = gPhyRatesSuppt[4][idx];
break;
case eCsrSuppRate_24Mbps:
fSupported = gPhyRatesSuppt[5][idx];
break;
case eCsrSuppRate_36Mbps:
fSupported = gPhyRatesSuppt[6][idx];
break;
case eCsrSuppRate_40Mbps:
fSupported = gPhyRatesSuppt[7][idx];
break;
case eCsrSuppRate_42Mbps:
fSupported = gPhyRatesSuppt[8][idx];
break;
case eCsrSuppRate_48Mbps:
fSupported = gPhyRatesSuppt[9][idx];
break;
case eCsrSuppRate_54Mbps:
fSupported = gPhyRatesSuppt[10][idx];
break;
case eCsrSuppRate_72Mbps:
fSupported = gPhyRatesSuppt[11][idx];
break;
case eCsrSuppRate_80Mbps:
fSupported = gPhyRatesSuppt[12][idx];
break;
case eCsrSuppRate_84Mbps:
fSupported = gPhyRatesSuppt[13][idx];
break;
case eCsrSuppRate_96Mbps:
fSupported = gPhyRatesSuppt[14][idx];
break;
case eCsrSuppRate_108Mbps:
fSupported = gPhyRatesSuppt[15][idx];
break;
case eCsrSuppRate_120Mbps:
fSupported = gPhyRatesSuppt[16][idx];
break;
case eCsrSuppRate_126Mbps:
fSupported = gPhyRatesSuppt[17][idx];
break;
case eCsrSuppRate_144Mbps:
fSupported = gPhyRatesSuppt[18][idx];
break;
case eCsrSuppRate_160Mbps:
fSupported = gPhyRatesSuppt[19][idx];
break;
case eCsrSuppRate_168Mbps:
fSupported = gPhyRatesSuppt[20][idx];
break;
case eCsrSuppRate_192Mbps:
fSupported = gPhyRatesSuppt[21][idx];
break;
case eCsrSuppRate_216Mbps:
fSupported = gPhyRatesSuppt[22][idx];
break;
case eCsrSuppRate_240Mbps:
fSupported = gPhyRatesSuppt[23][idx];
break;
default:
fSupported = FALSE;
break;
}
}
}
return fSupported;
}
static tANI_BOOLEAN csrIsRateSetMatch( tpAniSirGlobal pMac,
tDot11fIESuppRates *pBssSuppRates,
tDot11fIEExtSuppRates *pBssExtSuppRates )
{
tANI_BOOLEAN fMatch = TRUE;
tANI_U32 i;
// Validate that all of the Basic rates advertised in the Bss description are supported.
if ( pBssSuppRates )
{
for( i = 0; i < pBssSuppRates->num_rates; i++ )
{
if ( CSR_IS_BASIC_RATE( pBssSuppRates->rates[ i ] ) )
{
if ( !csrIsAggregateRateSupported( pMac, pBssSuppRates->rates[ i ] ) )
{
fMatch = FALSE;
break;
}
}
}
}
if ( fMatch && pBssExtSuppRates )
{
for( i = 0; i < pBssExtSuppRates->num_rates; i++ )
{
if ( CSR_IS_BASIC_RATE( pBssExtSuppRates->rates[ i ] ) )
{
if ( !csrIsAggregateRateSupported( pMac, pBssExtSuppRates->rates[ i ] ) )
{
fMatch = FALSE;
break;
}
}
}
}
return( fMatch );
}
//ppIes can be NULL. If caller want to get the *ppIes allocated by this function, pass in *ppIes = NULL
tANI_BOOLEAN csrMatchBSS( tHalHandle hHal, tSirBssDescription *pBssDesc, tCsrScanResultFilter *pFilter,
eCsrAuthType *pNegAuth, eCsrEncryptionType *pNegUc, eCsrEncryptionType *pNegMc,
tDot11fBeaconIEs **ppIes)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fRC = eANI_BOOLEAN_FALSE, fCheck;
tANI_U32 i;
tDot11fBeaconIEs *pIes = NULL;
tANI_U8 *pb;
do {
if( ( NULL == ppIes ) || ( *ppIes ) == NULL )
{
//If no IEs passed in, get our own.
if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pBssDesc, &pIes)))
{
break;
}
}
else
{
//Save the one pass in for local use
pIes = *ppIes;
}
//Check if caller wants P2P
fCheck = (!pFilter->p2pResult || pIes->P2PBeaconProbeRes.present);
if(!fCheck) break;
if(pIes->SSID.present)
{
for(i = 0; i < pFilter->SSIDs.numOfSSIDs; i++)
{
fCheck = csrIsSsidMatch( pMac, pFilter->SSIDs.SSIDList[i].SSID.ssId, pFilter->SSIDs.SSIDList[i].SSID.length,
pIes->SSID.ssid,
pIes->SSID.num_ssid, eANI_BOOLEAN_TRUE );
if ( fCheck ) break;
}
if(!fCheck) break;
}
fCheck = eANI_BOOLEAN_TRUE;
for(i = 0; i < pFilter->BSSIDs.numOfBSSIDs; i++)
{
fCheck = csrIsBssidMatch( pMac, (tCsrBssid *)&pFilter->BSSIDs.bssid[i], (tCsrBssid *)pBssDesc->bssId );
if ( fCheck ) break;
if (pFilter->p2pResult && pIes->P2PBeaconProbeRes.present)
{
fCheck = csrIsBssidMatch( pMac, (tCsrBssid *)&pFilter->BSSIDs.bssid[i],
(tCsrBssid *)pIes->P2PBeaconProbeRes.P2PDeviceInfo.P2PDeviceAddress );
if ( fCheck ) break;
}
}
if(!fCheck) break;
fCheck = eANI_BOOLEAN_TRUE;
for(i = 0; i < pFilter->ChannelInfo.numOfChannels; i++)
{
fCheck = csrIsChannelBandMatch( pMac, pFilter->ChannelInfo.ChannelList[i], pBssDesc );
if ( fCheck ) break;
}
if(!fCheck)
break;
#if defined WLAN_FEATURE_VOWIFI
/* If this is for measurement filtering */
if( pFilter->fMeasurement )
{
fRC = eANI_BOOLEAN_TRUE;
break;
}
#endif
if ( !csrIsPhyModeMatch( pMac, pFilter->phyMode, pBssDesc, NULL, NULL, pIes ) ) break;
if ( (!pFilter->bWPSAssociation) &&
!csrIsSecurityMatch( pMac, &pFilter->authType, &pFilter->EncryptionType, &pFilter->mcEncryptionType,
pBssDesc, pIes, pNegAuth, pNegUc, pNegMc ) ) break;
if ( !csrIsCapabilitiesMatch( pMac, pFilter->BSSType, pBssDesc ) ) break;
if ( !csrIsRateSetMatch( pMac, &pIes->SuppRates, &pIes->ExtSuppRates ) ) break;
//Tush-QoS: validate first if asked for APSD or WMM association
if ( (eCsrRoamWmmQbssOnly == pMac->roam.configParam.WMMSupportMode) &&
!CSR_IS_QOS_BSS(pIes) )
break;
//Check country. check even when pb is NULL because we may want to make sure
//AP has a country code in it if fEnforceCountryCodeMatch is set.
pb = ( pFilter->countryCode[0] ) ? ( pFilter->countryCode) : NULL;
fCheck = csrMatchCountryCode( pMac, pb, pIes );
if(!fCheck)
break;
#ifdef WLAN_FEATURE_VOWIFI_11R
if (pFilter->MDID.mdiePresent)
{
if (pBssDesc->mdiePresent)
{
if (pFilter->MDID.mobilityDomain != (pBssDesc->mdie[1] << 8 | pBssDesc->mdie[0]))
break;
}
else
break;
}
#endif
fRC = eANI_BOOLEAN_TRUE;
} while( 0 );
if( ppIes )
{
*ppIes = pIes;
}
else if( pIes )
{
palFreeMemory(pMac->hHdd, pIes);
}
return( fRC );
}
tANI_BOOLEAN csrMatchConnectedBSSSecurity( tpAniSirGlobal pMac, tCsrRoamConnectedProfile *pProfile,
tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIes)
{
tCsrEncryptionList ucEncryptionList, mcEncryptionList;
tCsrAuthList authList;
ucEncryptionList.numEntries = 1;
ucEncryptionList.encryptionType[0] = pProfile->EncryptionType;
mcEncryptionList.numEntries = 1;
mcEncryptionList.encryptionType[0] = pProfile->mcEncryptionType;
authList.numEntries = 1;
authList.authType[0] = pProfile->AuthType;
return( csrIsSecurityMatch( pMac, &authList, &ucEncryptionList, &mcEncryptionList, pBssDesc, pIes, NULL, NULL, NULL ));
}
tANI_BOOLEAN csrMatchBSSToConnectProfile( tHalHandle hHal, tCsrRoamConnectedProfile *pProfile,
tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIes )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_BOOLEAN fRC = eANI_BOOLEAN_FALSE, fCheck;
tDot11fBeaconIEs *pIesLocal = pIes;
do {
if( !pIes )
{
if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pBssDesc, &pIesLocal)))
{
break;
}
}
fCheck = eANI_BOOLEAN_TRUE;
if(pIesLocal->SSID.present)
{
tANI_BOOLEAN fCheckSsid = eANI_BOOLEAN_FALSE;
if(pProfile->SSID.length)
{
fCheckSsid = eANI_BOOLEAN_TRUE;
}
fCheck = csrIsSsidMatch( pMac, pProfile->SSID.ssId, pProfile->SSID.length,
pIesLocal->SSID.ssid, pIesLocal->SSID.num_ssid, fCheckSsid );
if(!fCheck) break;
}
if ( !csrMatchConnectedBSSSecurity( pMac, pProfile, pBssDesc, pIesLocal) ) break;
if ( !csrIsCapabilitiesMatch( pMac, pProfile->BSSType, pBssDesc ) ) break;
if ( !csrIsRateSetMatch( pMac, &pIesLocal->SuppRates, &pIesLocal->ExtSuppRates ) ) break;
fCheck = csrIsChannelBandMatch( pMac, pProfile->operationChannel, pBssDesc );
if(!fCheck)
break;
fRC = eANI_BOOLEAN_TRUE;
} while( 0 );
if( !pIes && pIesLocal )
{
//locally allocated
palFreeMemory(pMac->hHdd, pIesLocal);
}
return( fRC );
}
tANI_BOOLEAN csrRatesIsDot11RateSupported( tHalHandle hHal, tANI_U8 rate )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tANI_U16 n = BITS_OFF( rate, CSR_DOT11_BASIC_RATE_MASK );
return csrIsAggregateRateSupported( pMac, n );
}
tANI_U16 csrRatesMacPropToDot11( tANI_U16 Rate )
{
tANI_U16 ConvertedRate = Rate;
switch( Rate )
{
case SIR_MAC_RATE_1:
ConvertedRate = 2;
break;
case SIR_MAC_RATE_2:
ConvertedRate = 4;
break;
case SIR_MAC_RATE_5_5:
ConvertedRate = 11;
break;
case SIR_MAC_RATE_11:
ConvertedRate = 22;
break;
case SIR_MAC_RATE_6:
ConvertedRate = 12;
break;
case SIR_MAC_RATE_9:
ConvertedRate = 18;
break;
case SIR_MAC_RATE_12:
ConvertedRate = 24;
break;
case SIR_MAC_RATE_18:
ConvertedRate = 36;
break;
case SIR_MAC_RATE_24:
ConvertedRate = 48;
break;
case SIR_MAC_RATE_36:
ConvertedRate = 72;
break;
case SIR_MAC_RATE_42:
ConvertedRate = 84;
break;
case SIR_MAC_RATE_48:
ConvertedRate = 96;
break;
case SIR_MAC_RATE_54:
ConvertedRate = 108;
break;
case SIR_MAC_RATE_72:
ConvertedRate = 144;
break;
case SIR_MAC_RATE_84:
ConvertedRate = 168;
break;
case SIR_MAC_RATE_96:
ConvertedRate = 192;
break;
case SIR_MAC_RATE_108:
ConvertedRate = 216;
break;
case SIR_MAC_RATE_126:
ConvertedRate = 252;
break;
case SIR_MAC_RATE_144:
ConvertedRate = 288;
break;
case SIR_MAC_RATE_168:
ConvertedRate = 336;
break;
case SIR_MAC_RATE_192:
ConvertedRate = 384;
break;
case SIR_MAC_RATE_216:
ConvertedRate = 432;
break;
case SIR_MAC_RATE_240:
ConvertedRate = 480;
break;
case 0xff:
ConvertedRate = 0;
break;
}
return ConvertedRate;
}
tANI_U16 csrRatesFindBestRate( tSirMacRateSet *pSuppRates, tSirMacRateSet *pExtRates, tSirMacPropRateSet *pPropRates )
{
tANI_U8 i;
tANI_U16 nBest;
nBest = pSuppRates->rate[ 0 ] & ( ~CSR_DOT11_BASIC_RATE_MASK );
if(pSuppRates->numRates > SIR_MAC_RATESET_EID_MAX)
{
pSuppRates->numRates = SIR_MAC_RATESET_EID_MAX;
}
for ( i = 1U; i < pSuppRates->numRates; ++i )
{
nBest = (tANI_U16)CSR_MAX( nBest, pSuppRates->rate[ i ] & ( ~CSR_DOT11_BASIC_RATE_MASK ) );
}
if ( NULL != pExtRates )
{
for ( i = 0U; i < pExtRates->numRates; ++i )
{
nBest = (tANI_U16)CSR_MAX( nBest, pExtRates->rate[ i ] & ( ~CSR_DOT11_BASIC_RATE_MASK ) );
}
}
if ( NULL != pPropRates )
{
for ( i = 0U; i < pPropRates->numPropRates; ++i )
{
nBest = (tANI_U16)CSR_MAX( nBest, csrRatesMacPropToDot11( pPropRates->propRate[ i ] ) );
}
}
return nBest;
}
void csrReleaseProfile(tpAniSirGlobal pMac, tCsrRoamProfile *pProfile)
{
if(pProfile)
{
if(pProfile->BSSIDs.bssid)
{
palFreeMemory(pMac->hHdd, pProfile->BSSIDs.bssid);
pProfile->BSSIDs.bssid = NULL;
}
if(pProfile->SSIDs.SSIDList)
{
palFreeMemory(pMac->hHdd, pProfile->SSIDs.SSIDList);
pProfile->SSIDs.SSIDList = NULL;
}
if(pProfile->pWPAReqIE)
{
palFreeMemory(pMac->hHdd, pProfile->pWPAReqIE);
pProfile->pWPAReqIE = NULL;
}
if(pProfile->pRSNReqIE)
{
palFreeMemory(pMac->hHdd, pProfile->pRSNReqIE);
pProfile->pRSNReqIE = NULL;
}
#ifdef FEATURE_WLAN_WAPI
if(pProfile->pWAPIReqIE)
{
palFreeMemory(pMac->hHdd, pProfile->pWAPIReqIE);
pProfile->pWAPIReqIE = NULL;
}
#endif /* FEATURE_WLAN_WAPI */
if(pProfile->pAddIEScan)
{
palFreeMemory(pMac->hHdd, pProfile->pAddIEScan);
pProfile->pAddIEScan = NULL;
}
if(pProfile->pAddIEAssoc)
{
palFreeMemory(pMac->hHdd, pProfile->pAddIEAssoc);
pProfile->pAddIEAssoc = NULL;
}
{
palFreeMemory(pMac->hHdd, pProfile->pAddIEAssoc);
pProfile->pAddIEAssoc = NULL;
}
if(pProfile->ChannelInfo.ChannelList)
{
palFreeMemory(pMac->hHdd, pProfile->ChannelInfo.ChannelList);
pProfile->ChannelInfo.ChannelList = NULL;
}
palZeroMemory(pMac->hHdd, pProfile, sizeof(tCsrRoamProfile));
}
}
void csrFreeScanFilter(tpAniSirGlobal pMac, tCsrScanResultFilter *pScanFilter)
{
if(pScanFilter->BSSIDs.bssid)
{
palFreeMemory(pMac->hHdd, pScanFilter->BSSIDs.bssid);
pScanFilter->BSSIDs.bssid = NULL;
}
if(pScanFilter->ChannelInfo.ChannelList)
{
palFreeMemory(pMac->hHdd, pScanFilter->ChannelInfo.ChannelList);
pScanFilter->ChannelInfo.ChannelList = NULL;
}
if(pScanFilter->SSIDs.SSIDList)
{
palFreeMemory(pMac->hHdd, pScanFilter->SSIDs.SSIDList);
pScanFilter->SSIDs.SSIDList = NULL;
}
}
void csrFreeRoamProfile(tpAniSirGlobal pMac, tANI_U32 sessionId)
{
tCsrRoamSession *pSession = &pMac->roam.roamSession[sessionId];
if(pSession->pCurRoamProfile)
{
csrReleaseProfile(pMac, pSession->pCurRoamProfile);
palFreeMemory(pMac->hHdd, pSession->pCurRoamProfile);
pSession->pCurRoamProfile = NULL;
}
}
void csrFreeConnectBssDesc(tpAniSirGlobal pMac, tANI_U32 sessionId)
{
tCsrRoamSession *pSession = &pMac->roam.roamSession[sessionId];
if(pSession->pConnectBssDesc)
{
palFreeMemory(pMac->hHdd, pSession->pConnectBssDesc);
pSession->pConnectBssDesc = NULL;
}
}
tSirResultCodes csrGetDisassocRspStatusCode( tSirSmeDisassocRsp *pSmeDisassocRsp )
{
tANI_U8 *pBuffer = (tANI_U8 *)pSmeDisassocRsp;
tANI_U32 ret;
pBuffer += (sizeof(tANI_U16) + sizeof(tANI_U16) + sizeof(tSirMacAddr));
//tSirResultCodes is an enum, assuming is 32bit
//If we cannot make this assumption, use copymemory
pal_get_U32( pBuffer, &ret );
return( ( tSirResultCodes )ret );
}
tSirResultCodes csrGetDeAuthRspStatusCode( tSirSmeDeauthRsp *pSmeRsp )
{
tANI_U8 *pBuffer = (tANI_U8 *)pSmeRsp;
tANI_U32 ret;
pBuffer += (sizeof(tANI_U16) + sizeof(tANI_U16) + sizeof(tSirMacAddr));
//tSirResultCodes is an enum, assuming is 32bit
//If we cannot make this assumption, use copymemory
pal_get_U32( pBuffer, &ret );
return( ( tSirResultCodes )ret );
}
#if 0
tSirScanType csrGetScanType(tANI_U8 chnId, eRegDomainId domainId, tANI_U8 *countryCode)
{
tSirScanType scanType = eSIR_PASSIVE_SCAN;
tANI_U8 cc = 0;
while (cc++ < gCsrDomainChnInfo[domainId].numChannels)
{
if(chnId == gCsrDomainChnInfo[domainId].chnInfo[cc].chnId)
{
scanType = gCsrDomainChnInfo[domainId].chnInfo[cc].scanType;
break;
}
}
return (scanType);
}
#endif
tSirScanType csrGetScanType(tpAniSirGlobal pMac, tANI_U8 chnId)
{
tSirScanType scanType = eSIR_PASSIVE_SCAN;
eNVChannelEnabledType channelEnabledType;
channelEnabledType = vos_nv_getChannelEnabledState(chnId);
if( NV_CHANNEL_ENABLE == channelEnabledType)
{
scanType = eSIR_ACTIVE_SCAN;
}
return (scanType);
}
tANI_U8 csrToUpper( tANI_U8 ch )
{
tANI_U8 chOut;
if ( ch >= 'a' && ch <= 'z' )
{
chOut = ch - 'a' + 'A';
}
else
{
chOut = ch;
}
return( chOut );
}
tSirBssType csrTranslateBsstypeToMacType(eCsrRoamBssType csrtype)
{
tSirBssType ret;
switch(csrtype)
{
case eCSR_BSS_TYPE_INFRASTRUCTURE:
ret = eSIR_INFRASTRUCTURE_MODE;
break;
case eCSR_BSS_TYPE_IBSS:
case eCSR_BSS_TYPE_START_IBSS:
ret = eSIR_IBSS_MODE;
break;
case eCSR_BSS_TYPE_WDS_AP:
ret = eSIR_BTAMP_AP_MODE;
break;
case eCSR_BSS_TYPE_WDS_STA:
ret = eSIR_BTAMP_STA_MODE;
break;
case eCSR_BSS_TYPE_INFRA_AP:
ret = eSIR_INFRA_AP_MODE;
break;
case eCSR_BSS_TYPE_ANY:
default:
ret = eSIR_AUTO_MODE;
break;
}
return (ret);
}
//This function use the parameters to decide the CFG value.
//CSR never sets WNI_CFG_DOT11_MODE_ALL to the CFG
//So PE should not see WNI_CFG_DOT11_MODE_ALL when it gets the CFG value
eCsrCfgDot11Mode csrGetCfgDot11ModeFromCsrPhyMode(tCsrRoamProfile *pProfile, eCsrPhyMode phyMode, tANI_BOOLEAN fProprietary)
{
tANI_U32 cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG;
switch(phyMode)
{
case eCSR_DOT11_MODE_11a:
case eCSR_DOT11_MODE_11a_ONLY:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
break;
case eCSR_DOT11_MODE_11b:
case eCSR_DOT11_MODE_11b_ONLY:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
break;
case eCSR_DOT11_MODE_11g:
case eCSR_DOT11_MODE_11g_ONLY:
if(pProfile && (CSR_IS_INFRA_AP(pProfile)) && (phyMode == eCSR_DOT11_MODE_11g_ONLY))
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G_ONLY;
else
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
break;
case eCSR_DOT11_MODE_11n:
if(fProprietary)
{
cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
}
else
{
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
}
break;
case eCSR_DOT11_MODE_11n_ONLY:
if(pProfile && CSR_IS_INFRA_AP(pProfile))
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N_ONLY;
else
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
break;
case eCSR_DOT11_MODE_TAURUS:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
break;
case eCSR_DOT11_MODE_abg:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG;
break;
case eCSR_DOT11_MODE_AUTO:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_AUTO;
break;
#ifdef WLAN_FEATURE_11AC
case eCSR_DOT11_MODE_11ac:
if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC))
{
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
}
else
{
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
}
break;
case eCSR_DOT11_MODE_11ac_ONLY:
cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC_ONLY;
break;
#endif
default:
//No need to assign anything here
break;
}
return (cfgDot11Mode);
}
eHalStatus csrSetRegulatoryDomain(tpAniSirGlobal pMac, v_REGDOMAIN_t domainId, tANI_BOOLEAN *pfRestartNeeded)
{
eHalStatus status = eHAL_STATUS_SUCCESS;
tANI_BOOLEAN fRestart;
if(pMac->scan.domainIdCurrent == domainId)
{
//no change
fRestart = eANI_BOOLEAN_FALSE;
}
else if( !pMac->roam.configParam.fEnforceDefaultDomain )
{
pMac->scan.domainIdCurrent = domainId;
fRestart = eANI_BOOLEAN_TRUE;
}
else
{
//We cannot change the domain
status = eHAL_STATUS_CSR_WRONG_STATE;
fRestart = eANI_BOOLEAN_FALSE;
}
if(pfRestartNeeded)
{
*pfRestartNeeded = fRestart;
}
return (status);
}
v_REGDOMAIN_t csrGetCurrentRegulatoryDomain(tpAniSirGlobal pMac)
{
return (pMac->scan.domainIdCurrent);
}
eHalStatus csrGetRegulatoryDomainForCountry(tpAniSirGlobal pMac, tANI_U8 *pCountry, v_REGDOMAIN_t *pDomainId)
{
eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
VOS_STATUS vosStatus;
v_COUNTRYCODE_t countryCode;
v_REGDOMAIN_t domainId;
if(pCountry)
{
countryCode[0] = pCountry[0];
countryCode[1] = pCountry[1];
vosStatus = vos_nv_getRegDomainFromCountryCode( &domainId, countryCode );
if( VOS_IS_STATUS_SUCCESS(vosStatus) )
{
if( pDomainId )
{
*pDomainId = domainId;
}
status = eHAL_STATUS_SUCCESS;
}
else
{
smsLog(pMac, LOGW, FL(" doesn't match country %c%c"), pCountry[0], pCountry[1]);
status = eHAL_STATUS_INVALID_PARAMETER;
}
}
return (status);
}
//To check whether a country code matches the one in the IE
//Only check the first two characters, ignoring in/outdoor
//pCountry -- caller allocated buffer contain the country code that is checking against
//the one in pIes. It can be NULL.
//caller must provide pIes, it cannot be NULL
//This function always return TRUE if 11d support is not turned on.
tANI_BOOLEAN csrMatchCountryCode( tpAniSirGlobal pMac, tANI_U8 *pCountry, tDot11fBeaconIEs *pIes )
{
tANI_BOOLEAN fRet = eANI_BOOLEAN_TRUE;
v_REGDOMAIN_t domainId = REGDOMAIN_COUNT; //This is init to invalid value
eHalStatus status;
do
{
if( !csrIs11dSupported( pMac) )
{
break;
}
if( !pIes )
{
smsLog(pMac, LOGE, FL(" No IEs"));
break;
}
if( pMac->roam.configParam.fEnforceDefaultDomain ||
pMac->roam.configParam.fEnforceCountryCodeMatch )
{
//Make sure this country is recognizable
if( pIes->Country.present )
{
status = csrGetRegulatoryDomainForCountry( pMac, pIes->Country.country, &domainId );
if( !HAL_STATUS_SUCCESS( status ) )
{
status = csrGetRegulatoryDomainForCountry( pMac, pMac->scan.countryCode11d,(v_REGDOMAIN_t *) &domainId );
if( !HAL_STATUS_SUCCESS( status ) )
{
fRet = eANI_BOOLEAN_FALSE;
break;
}
}
}
//check whether it is needed to enforce to the default regulatory domain first
if( pMac->roam.configParam.fEnforceDefaultDomain )
{
if( domainId != pMac->scan.domainIdCurrent )
{
fRet = eANI_BOOLEAN_FALSE;
break;
}
}
if( pMac->roam.configParam.fEnforceCountryCodeMatch )
{
if( domainId >= REGDOMAIN_COUNT )
{
fRet = eANI_BOOLEAN_FALSE;
break;
}
}
}
if( pCountry )
{
tANI_U32 i;
if( !pIes->Country.present )
{
fRet = eANI_BOOLEAN_FALSE;
break;
}
// Convert the CountryCode characters to upper
for ( i = 0; i < WNI_CFG_COUNTRY_CODE_LEN - 1; i++ )
{
pCountry[i] = csrToUpper( pCountry[i] );
}
if( !palEqualMemory(pMac->hHdd, pIes->Country.country, pCountry, WNI_CFG_COUNTRY_CODE_LEN - 1) )
{
fRet = eANI_BOOLEAN_FALSE;
break;
}
}
} while(0);
return (fRet);
}
#if 0
eHalStatus csrSetCountryDomainMapping(tpAniSirGlobal pMac, tCsrCountryDomainMapping *pCountryDomainMapping)
{
eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
tANI_U32 i, j;
tANI_BOOLEAN fDomainChanged = eANI_BOOLEAN_FALSE;
tANI_U8 countryCode[WNI_CFG_COUNTRY_CODE_LEN];
i = WNI_CFG_COUNTRY_CODE_LEN;
//Get the currently used country code
status = ccmCfgGetStr(pMac, WNI_CFG_COUNTRY_CODE, countryCode, &i);
if(HAL_STATUS_SUCCESS(status))
{
if(pCountryDomainMapping && pCountryDomainMapping->numEntry)
{
for(i = 0; i < pCountryDomainMapping->numEntry; i++)
{
for(j = 0; j < eCSR_NUM_COUNTRY_INDEX; j++)
{
if(palEqualMemory(pMac->hHdd, gCsrCountryInfo[j].countryCode,
pCountryDomainMapping->pCountryInfo[i].countryCode, 2))
{
if(gCsrCountryInfo[j].domainId != pCountryDomainMapping->pCountryInfo[i].domainId)
{
gCsrCountryInfo[j].domainId = pCountryDomainMapping->pCountryInfo[i].domainId;
//Check whether it matches the currently used country code
//If matching, need to update base on the new domain setting.
if(palEqualMemory(pMac->hHdd, countryCode,
pCountryDomainMapping->pCountryInfo[i].countryCode, 2))
{
fDomainChanged = eANI_BOOLEAN_TRUE;
}
}
break;
}
}
}
status = eHAL_STATUS_SUCCESS;
if(fDomainChanged)
{
tCsrChannel *pChannelList;
if(pMac->scan.f11dInfoApplied)
{
//11d info already applied. Let's reapply with the new domain setting
if(pMac->scan.channels11d.numChannels)
{
pChannelList = &pMac->scan.channels11d;
}
else
{
pChannelList = &pMac->scan.base20MHzChannels;
}
}
else
{
//no 11d so we use the base channelist from EEPROM
pChannelList = &pMac->scan.base20MHzChannels;
}
//set the new domain's scan requirement to CFG
csrSetCfgScanControlList(pMac, countryCode, pChannelList);
}
}
}
return (status);
}
eHalStatus csrSetDomainScanSetting(tpAniSirGlobal pMac, tCsrDomainFreqInfo *pDomainFreqInfo)
{
eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
tANI_U32 i, j;
tANI_U16 freq;
if(pDomainFreqInfo && pDomainFreqInfo->numEntry && (pDomainFreqInfo->domainId < NUM_REG_DOMAINS))
{
tCsrDomainChnInfo *pDomainChnInfo = &gCsrDomainChnInfo[pDomainFreqInfo->domainId];
for(j = 0; j < pDomainChnInfo->numChannels; j++)
{
if(HAL_STATUS_SUCCESS(halPhyChIdToFreqConversion(pDomainChnInfo->chnInfo[j].chnId, &freq)))
{
for(i = 0; i < pDomainFreqInfo->numEntry; i++)
{
if((pDomainFreqInfo->pCsrScanFreqInfo[i].nStartFreq <= freq) &&
(freq <= pDomainFreqInfo->pCsrScanFreqInfo[i].nEndFreq))
{
pDomainChnInfo->chnInfo[j].scanType = pDomainFreqInfo->pCsrScanFreqInfo[i].scanType;
break;
}
}
}
else
{
smsLog(pMac, LOGW, " Failed to get frequency of channel %d", pDomainChnInfo->chnInfo[j].chnId);
}
}
status = eHAL_STATUS_SUCCESS;
}
return (status);
}
#endif
eHalStatus csrGetModifyProfileFields(tpAniSirGlobal pMac, tANI_U32 sessionId,
tCsrRoamModifyProfileFields *pModifyProfileFields)
{
if(!pModifyProfileFields)
{
return eHAL_STATUS_FAILURE;
}
palCopyMemory( pMac->hHdd, pModifyProfileFields,
&pMac->roam.roamSession[sessionId].connectedProfile.modifyProfileFields,
sizeof(tCsrRoamModifyProfileFields) );
return eHAL_STATUS_SUCCESS;
}
eHalStatus csrSetModifyProfileFields(tpAniSirGlobal pMac, tANI_U32 sessionId,
tCsrRoamModifyProfileFields *pModifyProfileFields)
{
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
palCopyMemory( pMac->hHdd, &pSession->connectedProfile.modifyProfileFields,
pModifyProfileFields,
sizeof(tCsrRoamModifyProfileFields) );
return eHAL_STATUS_SUCCESS;
}
#if 0
/* ---------------------------------------------------------------------------
\fn csrGetSupportedCountryCode
\brief this function is to get a list of the country code current being supported
\param pBuf - Caller allocated buffer with at least 3 bytes, upon success return,
this has the country code list. 3 bytes for each country code. This may be NULL if
caller wants to know the needed bytes.
\param pbLen - Caller allocated, as input, it indicates the length of pBuf. Upon success return,
this contains the length of the data in pBuf
\return eHalStatus
-------------------------------------------------------------------------------*/
eHalStatus csrGetSupportedCountryCode(tpAniSirGlobal pMac, tANI_U8 *pBuf, tANI_U32 *pbLen)
{
tANI_U32 numOfCountry = sizeof( gCsrCountryInfo ) / sizeof( gCsrCountryInfo[0] );
tANI_U32 numBytes = 0;
eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
if( pbLen )
{
numBytes = *pbLen;
//Consider it ok, at least we can return the number of bytes needed;
*pbLen = numOfCountry * WNI_CFG_COUNTRY_CODE_LEN;
status = eHAL_STATUS_SUCCESS;
if( pBuf && ( numBytes >= *pbLen ) )
{
//The ugly part starts.
//We may need to alter the data structure and find a way to make this faster.
tANI_U32 i;
for( i = 0; i < numOfCountry; i++ )
{
palCopyMemory( pMac->hHdd, pBuf + ( i * WNI_CFG_COUNTRY_CODE_LEN ),
gCsrCountryInfo[i].countryCode, WNI_CFG_COUNTRY_CODE_LEN );
}
}
}
return ( status );
}
#endif
/* ---------------------------------------------------------------------------
\fn csrGetSupportedCountryCode
\brief this function is to get a list of the country code current being supported
\param pBuf - Caller allocated buffer with at least 3 bytes, upon success return,
this has the country code list. 3 bytes for each country code. This may be NULL if
caller wants to know the needed bytes.
\param pbLen - Caller allocated, as input, it indicates the length of pBuf. Upon success return,
this contains the length of the data in pBuf
\return eHalStatus
-------------------------------------------------------------------------------*/
eHalStatus csrGetSupportedCountryCode(tpAniSirGlobal pMac, tANI_U8 *pBuf, tANI_U32 *pbLen)
{
eHalStatus status = eHAL_STATUS_SUCCESS;
VOS_STATUS vosStatus;
v_SIZE_t size = (v_SIZE_t)*pbLen;
vosStatus = vos_nv_getSupportedCountryCode( pBuf, &size, 1 );
//eiter way, return the value back
*pbLen = (tANI_U32)size;
//If pBuf is NULL, caller just want to get the size, consider it success
if(pBuf)
{
if( VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
tANI_U32 i, n = *pbLen / 3;
for( i = 0; i < n; i++ )
{
pBuf[i*3 + 2] = ' ';
}
}
else
{
status = eHAL_STATUS_FAILURE;
}
}
return (status);
}
//Upper layer to get the list of the base channels to scan for passively 11d info from csr
eHalStatus csrScanGetBaseChannels( tpAniSirGlobal pMac, tCsrChannelInfo * pChannelInfo )
{
eHalStatus status = eHAL_STATUS_FAILURE;
do
{
if(!pMac->scan.baseChannels.numChannels || !pChannelInfo)
{
break;
}
status = palAllocateMemory( pMac->hHdd, (void **)&pChannelInfo->ChannelList,
pMac->scan.baseChannels.numChannels );
if( !HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("csrScanGetBaseChannels: fail to allocate memory") );
break;
}
status = palCopyMemory( pMac->hHdd, pChannelInfo->ChannelList, pMac->scan.baseChannels.channelList,
pMac->scan.baseChannels.numChannels );
if( !HAL_STATUS_SUCCESS( status ) )
{
break;
}
pChannelInfo->numOfChannels = pMac->scan.baseChannels.numChannels;
}while(0);
return ( status );
}
tANI_BOOLEAN csrIsSetKeyAllowed(tpAniSirGlobal pMac, tANI_U32 sessionId)
{
tANI_BOOLEAN fRet = eANI_BOOLEAN_TRUE;
tCsrRoamSession *pSession;
pSession =CSR_GET_SESSION(pMac, sessionId);
/*This condition is not working for infra state. When infra is in not-connected state
* the pSession->pCurRoamProfile is NULL. And this function returns TRUE, that is incorrect.
* Since SAP requires to set key without any BSS started, it needs this condition to be met.
* In other words, this function is useless.
* The current work-around is to process setcontext_rsp and removekey_rsp no matter what the
* state is.
*/
smsLog( pMac, LOG2, FL(" is not what it intends to. Must be revisit or removed") );
if( (NULL == pSession) ||
( csrIsConnStateDisconnected( pMac, sessionId ) &&
(pSession->pCurRoamProfile != NULL) &&
(!(CSR_IS_INFRA_AP(pSession->pCurRoamProfile))) )
)
{
fRet = eANI_BOOLEAN_FALSE;
}
return ( fRet );
}
//no need to acquire lock for this basic function
tANI_U16 sme_ChnToFreq(tANI_U8 chanNum)
{
int i;
for (i = 0; i < NUM_RF_CHANNELS; i++)
{
if (rfChannels[i].channelNum == chanNum)
{
return rfChannels[i].targetFreq;
}
}
return (0);
}
/* Disconnect all active sessions by sending disassoc. This is mainly used to disconnect the remaining session when we
* transition from concurrent sessions to a single session. The use case is Infra STA and wifi direct multiple sessions are up and
* P2P session is removed. The Infra STA session remains and should resume BMPS if BMPS is enabled by default. However, there
* are some issues seen with BMPS resume during this transition and this is a workaround which will allow the Infra STA session to
* disconnect and auto connect back and enter BMPS this giving the same effect as resuming BMPS
*/
//Remove this code once SLM_Sessionization is supported
//BMPS_WORKAROUND_NOT_NEEDED
void csrDisconnectAllActiveSessions(tpAniSirGlobal pMac)
{
tANI_U8 i;
/* Disconnect all the active sessions */
for (i=0; i<CSR_ROAM_SESSION_MAX; i++)
{
if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
{
csrRoamDisconnectInternal(pMac, i, eCSR_DISCONNECT_REASON_UNSPECIFIED);
}
}
}
#ifdef FEATURE_WLAN_LFR
tANI_BOOLEAN csrIsChannelPresentInList(
tANI_U8 *pChannelList,
int numChannels,
tANI_U8 channel
)
{
int i = 0;
// Check for NULL pointer
if (!pChannelList || (numChannels == 0))
{
return FALSE;
}
// Look for the channel in the list
for (i = 0; i < numChannels; i++)
{
if (pChannelList[i] == channel)
return TRUE;
}
return FALSE;
}
VOS_STATUS csrAddToChannelListFront(
tANI_U8 *pChannelList,
int numChannels,
tANI_U8 channel
)
{
int i = 0;
// Check for NULL pointer
if (!pChannelList) return eHAL_STATUS_E_NULL_VALUE;
// Make room for the addition. (Start moving from the back.)
for (i = numChannels; i > 0; i--)
{
pChannelList[i] = pChannelList[i-1];
}
// Now add the NEW channel...at the front
pChannelList[0] = channel;
return eHAL_STATUS_SUCCESS;
}
#endif