/*----------------------------------------------------------------------------*/
VOID secPrivacyFreeForEntry(IN P_ADAPTER_T prAdapter, IN UINT_8 ucEntry)
{
P_WLAN_TABLE_T prWtbl;
ASSERT(prAdapter);
if (ucEntry > WTBL_SIZE)
return;
DBGLOG(RSN, TRACE, ("secPrivacyFreeForEntry %d", ucEntry));
prWtbl = prAdapter->rWifiVar.arWtbl;
prWtbl[ucEntry].ucUsed = FALSE;
prWtbl[ucEntry].ucKeyId = 0;
prWtbl[ucEntry].ucBssIndex = 0; /* Set non-Zero as default ? */
prWtbl[ucEntry].ucPairwise = 0;
kalMemSet(prWtbl[ucEntry].aucMacAddr, 0x0, MAC_ADDR_LEN);
prWtbl[ucEntry].ucStaIndex = 0xff;
#if DBG
{
P_HAL_WTBL_SEC_CONFIG_T prWtblCfg;
prWtblCfg = prAdapter->rWifiVar.arWtblCfg;
kalMemZero((PUINT_8) & prWtblCfg[ucEntry], sizeof(HAL_WTBL_SEC_CONFIG_T));
secPrivacyDumpWTBL3(prAdapter, ucEntry);
secCheckWTBLAssign(prAdapter);
}
#endif
}
static ssize_t procDbgLevelWrite(struct file *file, const char *buffer, size_t count, loff_t *data)
{
UINT_32 u4NewDbgModule, u4NewDbgLevel;
UINT_8 i = 0;
UINT_32 u4CopySize = sizeof(aucProcBuf);
UINT_8 *temp = &aucProcBuf[0];
kalMemSet(aucProcBuf, 0, u4CopySize);
if (u4CopySize >= count + 1)
u4CopySize = count;
if (copy_from_user(aucProcBuf, buffer, u4CopySize)) {
pr_err("error of copy from user\n");
return -EFAULT;
}
aucProcBuf[u4CopySize] = '\0';
while (temp) {
if (sscanf(temp, "0x%x:0x%x", &u4NewDbgModule, &u4NewDbgLevel) != 2) {
pr_info("debug module and debug level should be one byte in length\n");
break;
}
if (u4NewDbgModule == 0xFF) {
for (i = 0; i < DBG_MODULE_NUM; i++)
aucDebugModule[i] = u4NewDbgLevel & DBG_CLASS_MASK;
break;
} else if (u4NewDbgModule >= DBG_MODULE_NUM) {
pr_info("debug module index should less than %d\n", DBG_MODULE_NUM);
break;
}
aucDebugModule[u4NewDbgModule] = u4NewDbgLevel & DBG_CLASS_MASK;
temp = kalStrChr(temp, ',');
if (!temp)
break;
temp++; /* skip ',' */
}
return count;
}
/*----------------------------------------------------------------------------*/
int
mtk_cfg80211_connect (
struct wiphy *wiphy,
struct net_device *ndev,
struct cfg80211_connect_params *sme
)
{
P_GLUE_INFO_T prGlueInfo = NULL;
WLAN_STATUS rStatus;
UINT_32 u4BufLen;
ENUM_PARAM_ENCRYPTION_STATUS_T eEncStatus;
ENUM_PARAM_AUTH_MODE_T eAuthMode;
UINT_32 cipher;
PARAM_SSID_T rNewSsid;
BOOLEAN fgCarryWPSIE = FALSE;
ENUM_PARAM_OP_MODE_T eOpMode;
prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(wiphy);
ASSERT(prGlueInfo);
if (prGlueInfo->prAdapter->rWifiVar.rConnSettings.eOPMode > NET_TYPE_AUTO_SWITCH)
eOpMode = NET_TYPE_AUTO_SWITCH;
else
eOpMode = prGlueInfo->prAdapter->rWifiVar.rConnSettings.eOPMode;
rStatus = kalIoctl(prGlueInfo,
wlanoidSetInfrastructureMode,
&eOpMode,
sizeof(eOpMode),
FALSE,
FALSE,
TRUE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(INIT, INFO, ("wlanoidSetInfrastructureMode fail 0x%lx\n", rStatus));
return -EFAULT;
}
/* after set operation mode, key table are cleared */
/* reset wpa info */
prGlueInfo->rWpaInfo.u4WpaVersion = IW_AUTH_WPA_VERSION_DISABLED;
prGlueInfo->rWpaInfo.u4KeyMgmt = 0;
prGlueInfo->rWpaInfo.u4CipherGroup = IW_AUTH_CIPHER_NONE;
prGlueInfo->rWpaInfo.u4CipherPairwise = IW_AUTH_CIPHER_NONE;
prGlueInfo->rWpaInfo.u4AuthAlg = IW_AUTH_ALG_OPEN_SYSTEM;
#if CFG_SUPPORT_802_11W
prGlueInfo->rWpaInfo.u4Mfp = IW_AUTH_MFP_DISABLED;
#endif
if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
prGlueInfo->rWpaInfo.u4WpaVersion = IW_AUTH_WPA_VERSION_WPA;
else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
prGlueInfo->rWpaInfo.u4WpaVersion = IW_AUTH_WPA_VERSION_WPA2;
else
prGlueInfo->rWpaInfo.u4WpaVersion = IW_AUTH_WPA_VERSION_DISABLED;
switch (sme->auth_type) {
case NL80211_AUTHTYPE_OPEN_SYSTEM:
prGlueInfo->rWpaInfo.u4AuthAlg = IW_AUTH_ALG_OPEN_SYSTEM;
break;
case NL80211_AUTHTYPE_SHARED_KEY:
prGlueInfo->rWpaInfo.u4AuthAlg = IW_AUTH_ALG_SHARED_KEY;
break;
default:
prGlueInfo->rWpaInfo.u4AuthAlg = IW_AUTH_ALG_OPEN_SYSTEM | IW_AUTH_ALG_SHARED_KEY;
break;
}
if (sme->crypto.n_ciphers_pairwise) {
prGlueInfo->prAdapter->rWifiVar.rConnSettings.rRsnInfo.au4PairwiseKeyCipherSuite[0] = sme->crypto.ciphers_pairwise[0];
switch (sme->crypto.ciphers_pairwise[0]) {
case WLAN_CIPHER_SUITE_WEP40:
prGlueInfo->rWpaInfo.u4CipherPairwise = IW_AUTH_CIPHER_WEP40;
break;
case WLAN_CIPHER_SUITE_WEP104:
prGlueInfo->rWpaInfo.u4CipherPairwise = IW_AUTH_CIPHER_WEP104;
break;
case WLAN_CIPHER_SUITE_TKIP:
prGlueInfo->rWpaInfo.u4CipherPairwise = IW_AUTH_CIPHER_TKIP;
break;
case WLAN_CIPHER_SUITE_CCMP:
prGlueInfo->rWpaInfo.u4CipherPairwise = IW_AUTH_CIPHER_CCMP;
break;
case WLAN_CIPHER_SUITE_AES_CMAC:
prGlueInfo->rWpaInfo.u4CipherPairwise = IW_AUTH_CIPHER_CCMP;
break;
default:
DBGLOG(REQ, WARN, ("invalid cipher pairwise (%d)\n",
sme->crypto.ciphers_pairwise[0]));
return -EINVAL;
}
}
if (sme->crypto.cipher_group) {
prGlueInfo->prAdapter->rWifiVar.rConnSettings.rRsnInfo.u4GroupKeyCipherSuite = sme->crypto.cipher_group;
switch (sme->crypto.cipher_group) {
case WLAN_CIPHER_SUITE_WEP40:
prGlueInfo->rWpaInfo.u4CipherGroup = IW_AUTH_CIPHER_WEP40;
break;
case WLAN_CIPHER_SUITE_WEP104:
prGlueInfo->rWpaInfo.u4CipherGroup = IW_AUTH_CIPHER_WEP104;
break;
case WLAN_CIPHER_SUITE_TKIP:
prGlueInfo->rWpaInfo.u4CipherGroup = IW_AUTH_CIPHER_TKIP;
break;
case WLAN_CIPHER_SUITE_CCMP:
prGlueInfo->rWpaInfo.u4CipherGroup = IW_AUTH_CIPHER_CCMP;
break;
case WLAN_CIPHER_SUITE_AES_CMAC:
prGlueInfo->rWpaInfo.u4CipherGroup = IW_AUTH_CIPHER_CCMP;
break;
default:
DBGLOG(REQ, WARN, ("invalid cipher group (%d)\n",
sme->crypto.cipher_group));
return -EINVAL;
}
}
if (sme->crypto.n_akm_suites) {
prGlueInfo->prAdapter->rWifiVar.rConnSettings.rRsnInfo.au4AuthKeyMgtSuite[0] = sme->crypto.akm_suites[0];
if (prGlueInfo->rWpaInfo.u4WpaVersion == IW_AUTH_WPA_VERSION_WPA) {
switch (sme->crypto.akm_suites[0]) {
case WLAN_AKM_SUITE_8021X:
eAuthMode = AUTH_MODE_WPA;
break;
case WLAN_AKM_SUITE_PSK:
eAuthMode = AUTH_MODE_WPA_PSK;
break;
default:
DBGLOG(REQ, WARN, ("invalid cipher group (%d)\n",
sme->crypto.cipher_group));
return -EINVAL;
}
} else if (prGlueInfo->rWpaInfo.u4WpaVersion == IW_AUTH_WPA_VERSION_WPA2) {
switch (sme->crypto.akm_suites[0]) {
case WLAN_AKM_SUITE_8021X:
eAuthMode = AUTH_MODE_WPA2;
break;
case WLAN_AKM_SUITE_PSK:
eAuthMode = AUTH_MODE_WPA2_PSK;
break;
default:
DBGLOG(REQ, WARN, ("invalid cipher group (%d)\n",
sme->crypto.cipher_group));
return -EINVAL;
}
}
}
if (prGlueInfo->rWpaInfo.u4WpaVersion == IW_AUTH_WPA_VERSION_DISABLED) {
eAuthMode = (prGlueInfo->rWpaInfo.u4AuthAlg == IW_AUTH_ALG_OPEN_SYSTEM) ?
AUTH_MODE_OPEN : AUTH_MODE_AUTO_SWITCH;
}
prGlueInfo->rWpaInfo.fgPrivacyInvoke = sme->privacy;
//prGlueInfo->prAdapter->rWifiVar.rConnSettings.fgWapiMode = FALSE;
//prGlueInfo->prAdapter->prGlueInfo->u2WapiAssocInfoIESz = 0;
prGlueInfo->fgWpsActive = FALSE;
//prGlueInfo->prAdapter->prGlueInfo->u2WSCAssocInfoIELen = 0;
if (sme->ie && sme->ie_len > 0) {
WLAN_STATUS rStatus;
UINT_32 u4BufLen;
PUINT_8 prDesiredIE = NULL;
#if CFG_SUPPORT_WAPI
rStatus = kalIoctl(prGlueInfo,
wlanoidSetWapiAssocInfo,
sme->ie,
sme->ie_len,
FALSE,
FALSE,
FALSE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(SEC, WARN, ("[wapi] set wapi assoc info error:%lx\n", rStatus));
}
#endif
#if CFG_SUPPORT_WPS2
if (wextSrchDesiredWPSIE(sme->ie,
sme->ie_len,
0xDD,
(PUINT_8 *)&prDesiredIE)) {
prGlueInfo->fgWpsActive = TRUE;
fgCarryWPSIE = TRUE;
rStatus = kalIoctl(prGlueInfo,
wlanoidSetWSCAssocInfo,
prDesiredIE,
IE_SIZE(prDesiredIE),
FALSE,
FALSE,
FALSE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(SEC, WARN, ("WSC] set WSC assoc info error:%lx\n", rStatus));
}
}
#endif
}
/* clear WSC Assoc IE buffer in case WPS IE is not detected */
if(fgCarryWPSIE == FALSE) {
kalMemZero(&prGlueInfo->aucWSCAssocInfoIE, 200);
prGlueInfo->u2WSCAssocInfoIELen = 0;
}
rStatus = kalIoctl(prGlueInfo,
wlanoidSetAuthMode,
&eAuthMode,
sizeof(eAuthMode),
FALSE,
FALSE,
FALSE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(REQ, WARN, ("set auth mode error:%lx\n", rStatus));
}
cipher = prGlueInfo->rWpaInfo.u4CipherGroup | prGlueInfo->rWpaInfo.u4CipherPairwise;
if (prGlueInfo->rWpaInfo.fgPrivacyInvoke) {
if (cipher & IW_AUTH_CIPHER_CCMP) {
eEncStatus = ENUM_ENCRYPTION3_ENABLED;
}
else if (cipher & IW_AUTH_CIPHER_TKIP) {
eEncStatus = ENUM_ENCRYPTION2_ENABLED;
}
else if (cipher & (IW_AUTH_CIPHER_WEP104 | IW_AUTH_CIPHER_WEP40)) {
eEncStatus = ENUM_ENCRYPTION1_ENABLED;
}
else if (cipher & IW_AUTH_CIPHER_NONE) {
if (prGlueInfo->rWpaInfo.fgPrivacyInvoke)
eEncStatus = ENUM_ENCRYPTION1_ENABLED;
else
eEncStatus = ENUM_ENCRYPTION_DISABLED;
}
else {
eEncStatus = ENUM_ENCRYPTION_DISABLED;
}
}
else {
eEncStatus = ENUM_ENCRYPTION_DISABLED;
}
rStatus = kalIoctl(prGlueInfo,
wlanoidSetEncryptionStatus,
&eEncStatus,
sizeof(eEncStatus),
FALSE,
FALSE,
FALSE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(REQ, WARN, ("set encryption mode error:%lx\n", rStatus));
}
if (sme->key_len != 0 && prGlueInfo->rWpaInfo.u4WpaVersion == IW_AUTH_WPA_VERSION_DISABLED) {
P_PARAM_WEP_T prWepKey = (P_PARAM_WEP_T) wepBuf;
kalMemSet(prWepKey, 0, sizeof(prWepKey));
prWepKey->u4Length = 12 + sme->key_len;
prWepKey->u4KeyLength = (UINT_32) sme->key_len;
prWepKey->u4KeyIndex = (UINT_32) sme->key_idx;
prWepKey->u4KeyIndex |= BIT(31);
if (prWepKey->u4KeyLength > 32) {
DBGLOG(REQ, WARN, ("Too long key length (%u)\n", prWepKey->u4KeyLength));
return -EINVAL;
}
kalMemCopy(prWepKey->aucKeyMaterial, sme->key, prWepKey->u4KeyLength);
rStatus = kalIoctl(prGlueInfo,
wlanoidSetAddWep,
prWepKey,
prWepKey->u4Length,
FALSE,
FALSE,
TRUE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(INIT, INFO, ("wlanoidSetAddWep fail 0x%lx\n", rStatus));
return -EFAULT;
}
}
if(sme->ssid_len > 0) {
/* connect by SSID */
COPY_SSID(rNewSsid.aucSsid, rNewSsid.u4SsidLen, sme->ssid, sme->ssid_len);
rStatus = kalIoctl(prGlueInfo,
wlanoidSetSsid,
(PVOID) &rNewSsid,
sizeof(PARAM_SSID_T),
FALSE,
FALSE,
TRUE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(REQ, WARN, ("set SSID:%lx\n", rStatus));
return -EINVAL;
}
}
else {
/* connect by BSSID */
rStatus = kalIoctl(prGlueInfo,
wlanoidSetBssid,
(PVOID) sme->bssid,
sizeof(MAC_ADDR_LEN),
FALSE,
FALSE,
TRUE,
FALSE,
&u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(REQ, WARN, ("set BSSID:%lx\n", rStatus));
return -EINVAL;
}
}
return 0;
}
