2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 * Purpose: handle wpa supplicant ioctl input/out functions
45 /*--------------------- Static Definitions -------------------------*/
47 #define VIAWGET_WPA_MAX_BUF_SIZE 1024
51 static const int frequency_list[] = {
52 2412, 2417, 2422, 2427, 2432, 2437, 2442,
53 2447, 2452, 2457, 2462, 2467, 2472, 2484
55 /*--------------------- Static Classes ----------------------------*/
57 /*--------------------- Static Variables --------------------------*/
58 //static int msglevel =MSG_LEVEL_DEBUG;
59 static int msglevel =MSG_LEVEL_INFO;
61 /*--------------------- Static Functions --------------------------*/
66 /*--------------------- Export Variables --------------------------*/
67 static void wpadev_setup(struct net_device *dev)
69 dev->type = ARPHRD_IEEE80211;
70 dev->hard_header_len = ETH_HLEN;
72 dev->addr_len = ETH_ALEN;
73 dev->tx_queue_len = 1000;
75 memset(dev->broadcast,0xFF, ETH_ALEN);
77 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
82 * register netdev for wpa supplicant deamon
94 static int wpa_init_wpadev(PSDevice pDevice)
97 struct net_device *dev = pDevice->dev;
100 pDevice->wpadev = alloc_netdev(sizeof(PSDevice), "vntwpa", wpadev_setup);
101 if (pDevice->wpadev == NULL)
104 wpadev_priv = netdev_priv(pDevice->wpadev);
105 *wpadev_priv = *pDevice;
106 memcpy(pDevice->wpadev->dev_addr, dev->dev_addr, ETH_ALEN);
107 pDevice->wpadev->base_addr = dev->base_addr;
108 pDevice->wpadev->irq = dev->irq;
109 pDevice->wpadev->mem_start = dev->mem_start;
110 pDevice->wpadev->mem_end = dev->mem_end;
111 ret = register_netdev(pDevice->wpadev);
113 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: register_netdev(WPA) failed!\n",
115 free_netdev(pDevice->wpadev);
119 if (pDevice->skb == NULL) {
120 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
121 if (pDevice->skb == NULL)
125 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: Registered netdev %s for WPA management\n",
126 dev->name, pDevice->wpadev->name);
134 * unregister net_device (wpadev)
145 static int wpa_release_wpadev(PSDevice pDevice)
148 dev_kfree_skb(pDevice->skb);
152 if (pDevice->wpadev) {
153 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: Netdevice %s unregistered\n",
154 pDevice->dev->name, pDevice->wpadev->name);
155 unregister_netdev(pDevice->wpadev);
156 free_netdev(pDevice->wpadev);
157 pDevice->wpadev = NULL;
169 * Set enable/disable dev for wpa supplicant deamon
181 int wpa_set_wpadev(PSDevice pDevice, int val)
184 return wpa_init_wpadev(pDevice);
186 return wpa_release_wpadev(pDevice);
191 * Set WPA algorithm & keys
203 int wpa_set_keys(PSDevice pDevice, void *ctx, BOOL fcpfkernel)
205 struct viawget_wpa_param *param=ctx;
206 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
207 DWORD dwKeyIndex = 0;
208 BYTE abyKey[MAX_KEY_LEN];
209 BYTE abySeq[MAX_KEY_LEN];
211 // NDIS_802_11_KEY_RSC KeyRSC;
212 BYTE byKeyDecMode = KEY_CTL_WEP;
217 if (param->u.wpa_key.alg_name > WPA_ALG_CCMP)
220 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "param->u.wpa_key.alg_name = %d \n", param->u.wpa_key.alg_name);
221 if (param->u.wpa_key.alg_name == WPA_ALG_NONE) {
222 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
223 pDevice->bEncryptionEnable = FALSE;
224 pDevice->byKeyIndex = 0;
225 pDevice->bTransmitKey = FALSE;
226 for (uu=0; uu<MAX_KEY_TABLE; uu++) {
227 MACvDisableKeyEntry(pDevice, uu);
232 spin_unlock_irq(&pDevice->lock);
233 if(param->u.wpa_key.key && fcpfkernel) {
234 memcpy(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len);
237 if (param->u.wpa_key.key &&
238 copy_from_user(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len)) {
239 spin_lock_irq(&pDevice->lock);
243 spin_lock_irq(&pDevice->lock);
245 dwKeyIndex = (DWORD)(param->u.wpa_key.key_index);
247 if (param->u.wpa_key.alg_name == WPA_ALG_WEP) {
248 if (dwKeyIndex > 3) {
252 if (param->u.wpa_key.set_tx) {
253 pDevice->byKeyIndex = (BYTE)dwKeyIndex;
254 pDevice->bTransmitKey = TRUE;
255 dwKeyIndex |= (1 << 31);
257 KeybSetDefaultKey( pDevice,
259 dwKeyIndex & ~(BIT30 | USE_KEYRSC),
260 param->u.wpa_key.key_len,
267 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
268 pDevice->bEncryptionEnable = TRUE;
272 spin_unlock_irq(&pDevice->lock);
273 if(param->u.wpa_key.seq && fcpfkernel) {
274 memcpy(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len);
277 if (param->u.wpa_key.seq &&
278 copy_from_user(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len)) {
279 spin_lock_irq(&pDevice->lock);
283 spin_lock_irq(&pDevice->lock);
285 if (param->u.wpa_key.seq_len > 0) {
286 for (ii = 0 ; ii < param->u.wpa_key.seq_len ; ii++) {
288 LODWORD(KeyRSC) |= (abySeq[ii] << (ii * 8));
290 HIDWORD(KeyRSC) |= (abySeq[ii] << ((ii-4) * 8));
291 //KeyRSC |= (abySeq[ii] << (ii * 8));
293 dwKeyIndex |= 1 << 29;
296 if (param->u.wpa_key.key_index >= MAX_GROUP_KEY) {
297 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return dwKeyIndex > 3\n");
301 if (param->u.wpa_key.alg_name == WPA_ALG_TKIP) {
302 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
305 if (param->u.wpa_key.alg_name == WPA_ALG_CCMP) {
306 pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
309 if (param->u.wpa_key.set_tx)
310 dwKeyIndex |= (1 << 31);
313 if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)
314 byKeyDecMode = KEY_CTL_CCMP;
315 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
316 byKeyDecMode = KEY_CTL_TKIP;
318 byKeyDecMode = KEY_CTL_WEP;
320 // Fix HCT test that set 256 bits KEY and Ndis802_11Encryption3Enabled
321 if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
322 if (param->u.wpa_key.key_len == MAX_KEY_LEN)
323 byKeyDecMode = KEY_CTL_TKIP;
324 else if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
325 byKeyDecMode = KEY_CTL_WEP;
326 else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
327 byKeyDecMode = KEY_CTL_WEP;
328 } else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
329 if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
330 byKeyDecMode = KEY_CTL_WEP;
331 else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
332 byKeyDecMode = KEY_CTL_WEP;
335 // Check TKIP key length
336 if ((byKeyDecMode == KEY_CTL_TKIP) &&
337 (param->u.wpa_key.key_len != MAX_KEY_LEN)) {
338 // TKIP Key must be 256 bits
339 //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - TKIP Key must be 256 bits\n"));
340 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return- TKIP Key must be 256 bits!\n");
343 // Check AES key length
344 if ((byKeyDecMode == KEY_CTL_CCMP) &&
345 (param->u.wpa_key.key_len != AES_KEY_LEN)) {
346 // AES Key must be 128 bits
347 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return - AES Key must be 128 bits\n");
352 if (IS_BROADCAST_ADDRESS(¶m->addr[0]) || (param->addr == NULL)) {
353 // If IS_BROADCAST_ADDRESS, set the key as every key entry's group key.
354 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Groupe Key Assign.\n");
356 if ((KeybSetAllGroupKey(pDevice,
359 param->u.wpa_key.key_len,
364 (KeybSetDefaultKey(pDevice,
367 param->u.wpa_key.key_len,
372 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GROUP Key Assign.\n");
375 //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -KeybSetDefaultKey Fail.0\n"));
380 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Assign.\n");
381 // BSSID not 0xffffffffffff
382 // Pairwise Key can't be WEP
383 if (byKeyDecMode == KEY_CTL_WEP) {
384 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key can't be WEP\n");
388 dwKeyIndex |= (1 << 30); // set pairwise key
389 if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
390 //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - WMAC_CONFIG_IBSS_STA\n"));
393 if (KeybSetKey(pDevice,
397 param->u.wpa_key.key_len,
402 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Set\n");
406 if (IS_ETH_ADDRESS_EQUAL(¶m->addr[0], pDevice->abyBSSID)) {
407 //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -Key Table Full.2\n"));
411 // Save Key and configure just before associate/reassociate to BSSID
412 // we do not implement now
416 } // BSSID not 0xffffffffffff
417 if ((ret == 0) && ((param->u.wpa_key.set_tx) != 0)) {
418 pDevice->byKeyIndex = (BYTE)param->u.wpa_key.key_index;
419 pDevice->bTransmitKey = TRUE;
421 pDevice->bEncryptionEnable = TRUE;
424 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " key=%x-%x-%x-%x-%x-xxxxx \n",
425 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][0],
426 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][1],
427 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][2],
428 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][3],
429 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][4]
440 * enable wpa auth & mode
452 static int wpa_set_wpa(PSDevice pDevice,
453 struct viawget_wpa_param *param)
456 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
459 pMgmt->eAuthenMode = WMAC_AUTH_OPEN;
460 pMgmt->bShareKeyAlgorithm = FALSE;
482 static int wpa_set_disassociate(PSDevice pDevice,
483 struct viawget_wpa_param *param)
485 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
488 spin_lock_irq(&pDevice->lock);
489 if (pDevice->bLinkPass) {
490 if (!memcmp(param->addr, pMgmt->abyCurrBSSID, 6))
491 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
493 spin_unlock_irq(&pDevice->lock);
502 * enable scan process
514 static int wpa_set_scan(PSDevice pDevice,
515 struct viawget_wpa_param *param)
519 //2007-0919-01<Add>by MikeLiu
520 /**set ap_scan=1&&scan_ssid=1 under hidden ssid mode**/
521 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
522 PWLAN_IE_SSID pItemSSID;
523 printk("wpa_set_scan-->desired [ssid=%s,ssid_len=%d]\n",
524 param->u.scan_req.ssid,param->u.scan_req.ssid_len);
526 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
527 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
528 pItemSSID->byElementID = WLAN_EID_SSID;
529 memcpy(pItemSSID->abySSID, param->u.scan_req.ssid, param->u.scan_req.ssid_len);
530 pItemSSID->len = param->u.scan_req.ssid_len;
532 spin_lock_irq(&pDevice->lock);
533 BSSvClearBSSList((void *) pDevice, pDevice->bLinkPass);
534 /* bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL); */
535 bScheduleCommand((void *) pDevice,
537 pMgmt->abyDesireSSID);
538 spin_unlock_irq(&pDevice->lock);
559 static int wpa_get_bssid(PSDevice pDevice,
560 struct viawget_wpa_param *param)
562 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
564 memcpy(param->u.wpa_associate.bssid, pMgmt->abyCurrBSSID , 6);
585 static int wpa_get_ssid(PSDevice pDevice,
586 struct viawget_wpa_param *param)
588 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
589 PWLAN_IE_SSID pItemSSID;
592 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
594 memcpy(param->u.wpa_associate.ssid, pItemSSID->abySSID , pItemSSID->len);
595 param->u.wpa_associate.ssid_len = pItemSSID->len;
616 static int wpa_get_scan(PSDevice pDevice,
617 struct viawget_wpa_param *param)
619 struct viawget_scan_result *scan_buf;
620 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
621 PWLAN_IE_SSID pItemSSID;
627 long ldBm;//James //add
629 //******mike:bubble sort by stronger RSSI*****//
635 ptempBSS = kmalloc(sizeof(KnownBSS), (int)GFP_ATOMIC);
637 if (ptempBSS == NULL) {
639 printk("bubble sort kmalloc memory fail@@@\n");
647 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
649 for (jj = 0; jj < MAX_BSS_NUM - ii - 1; jj++) {
651 if ((pMgmt->sBSSList[jj].bActive != TRUE) ||
653 ((pMgmt->sBSSList[jj].uRSSI>pMgmt->sBSSList[jj+1].uRSSI) &&(pMgmt->sBSSList[jj+1].bActive!=FALSE))) {
655 memcpy(ptempBSS,&pMgmt->sBSSList[jj],sizeof(KnownBSS));
657 memcpy(&pMgmt->sBSSList[jj],&pMgmt->sBSSList[jj+1],sizeof(KnownBSS));
659 memcpy(&pMgmt->sBSSList[jj+1],ptempBSS,sizeof(KnownBSS));
669 // printk("bubble sort result:\n");
672 pBSS = &(pMgmt->sBSSList[0]);
673 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
674 pBSS = &(pMgmt->sBSSList[ii]);
680 pBuf = kcalloc(count, sizeof(struct viawget_scan_result), (int)GFP_ATOMIC);
686 scan_buf = (struct viawget_scan_result *)pBuf;
687 pBSS = &(pMgmt->sBSSList[0]);
688 for (ii = 0, jj = 0; ii < MAX_BSS_NUM ; ii++) {
689 pBSS = &(pMgmt->sBSSList[ii]);
693 memcpy(scan_buf->bssid, pBSS->abyBSSID, WLAN_BSSID_LEN);
694 pItemSSID = (PWLAN_IE_SSID)pBSS->abySSID;
695 memcpy(scan_buf->ssid, pItemSSID->abySSID, pItemSSID->len);
696 scan_buf->ssid_len = pItemSSID->len;
697 scan_buf->freq = frequency_list[pBSS->uChannel-1];
698 scan_buf->caps = pBSS->wCapInfo; //DavidWang for sharemode
699 //20080717-05,<Add> by James Li
700 RFvRSSITodBm(pDevice, (BYTE)(pBSS->uRSSI), &ldBm);
702 scan_buf->qual = 100;
703 }else if(-ldBm > 90) {
706 scan_buf->qual=(40-(-ldBm-50))*100/40;
710 //scan_buf->caps = pBSS->wCapInfo;
713 scan_buf->level = ldBm;
714 //20080717-05,<Add> by James Li--End
715 //scan_buf->maxrate =
716 if (pBSS->wWPALen != 0) {
717 scan_buf->wpa_ie_len = pBSS->wWPALen;
718 memcpy(scan_buf->wpa_ie, pBSS->byWPAIE, pBSS->wWPALen);
720 if (pBSS->wRSNLen != 0) {
721 scan_buf->rsn_ie_len = pBSS->wRSNLen;
722 memcpy(scan_buf->rsn_ie, pBSS->byRSNIE, pBSS->wRSNLen);
724 scan_buf = (struct viawget_scan_result *)((PBYTE)scan_buf + sizeof(struct viawget_scan_result));
732 if (copy_to_user(param->u.scan_results.buf, pBuf, sizeof(struct viawget_scan_result) * count)) {
735 param->u.scan_results.scan_count = count;
736 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " param->u.scan_results.scan_count = %d\n", count)
746 * set associate with AP
758 static int wpa_set_associate(PSDevice pDevice,
759 struct viawget_wpa_param *param)
761 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
762 PWLAN_IE_SSID pItemSSID;
763 BYTE abyNullAddr[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
766 BOOL bwepEnabled=FALSE;
768 // set key type & algorithm
769 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pairwise_suite = %d\n", param->u.wpa_associate.pairwise_suite);
770 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "group_suite = %d\n", param->u.wpa_associate.group_suite);
771 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "key_mgmt_suite = %d\n", param->u.wpa_associate.key_mgmt_suite);
772 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "auth_alg = %d\n", param->u.wpa_associate.auth_alg);
773 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "mode = %d\n", param->u.wpa_associate.mode);
774 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wpa_ie_len = %d\n", param->u.wpa_associate.wpa_ie_len);
775 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Roaming dBm = %d\n", param->u.wpa_associate.roam_dbm); //Davidwang
777 if (param->u.wpa_associate.wpa_ie &&
778 copy_from_user(&abyWPAIE[0], param->u.wpa_associate.wpa_ie, param->u.wpa_associate.wpa_ie_len))
781 if (param->u.wpa_associate.mode == 1)
782 pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
784 pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
787 if (memcmp(param->u.wpa_associate.bssid, &abyNullAddr[0], 6) != 0)
788 memcpy(pMgmt->abyDesireBSSID, param->u.wpa_associate.bssid, 6);
790 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
791 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
792 pItemSSID->byElementID = WLAN_EID_SSID;
793 pItemSSID->len = param->u.wpa_associate.ssid_len;
794 memcpy(pItemSSID->abySSID, param->u.wpa_associate.ssid, pItemSSID->len);
796 if (param->u.wpa_associate.wpa_ie_len == 0) {
797 if (param->u.wpa_associate.auth_alg & AUTH_ALG_SHARED_KEY)
798 pMgmt->eAuthenMode = WMAC_AUTH_SHAREKEY;
800 pMgmt->eAuthenMode = WMAC_AUTH_OPEN;
801 } else if (abyWPAIE[0] == RSN_INFO_ELEM) {
802 if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_PSK)
803 pMgmt->eAuthenMode = WMAC_AUTH_WPA2PSK;
805 pMgmt->eAuthenMode = WMAC_AUTH_WPA2;
807 if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_WPA_NONE)
808 pMgmt->eAuthenMode = WMAC_AUTH_WPANONE;
809 else if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_PSK)
810 pMgmt->eAuthenMode = WMAC_AUTH_WPAPSK;
812 pMgmt->eAuthenMode = WMAC_AUTH_WPA;
815 switch (param->u.wpa_associate.pairwise_suite) {
817 pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
820 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
824 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
826 // printk("****************wpa_set_associate:set CIPHER_WEP40_104\n");
829 if (param->u.wpa_associate.group_suite == CIPHER_CCMP)
830 pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
832 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
835 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
838 pMgmt->Roam_dbm = param->u.wpa_associate.roam_dbm;
839 // if ((pMgmt->Roam_dbm > 40)&&(pMgmt->Roam_dbm<80))
840 // pDevice->bEnableRoaming = TRUE;
842 if (pMgmt->eAuthenMode == WMAC_AUTH_SHAREKEY) { //@wep-sharekey
843 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
844 pMgmt->bShareKeyAlgorithm = TRUE;
846 else if (pMgmt->eAuthenMode == WMAC_AUTH_OPEN) {
847 if(bwepEnabled==TRUE) { //@open-wep
848 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
851 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
854 //mike save old encryption status
855 pDevice->eOldEncryptionStatus = pDevice->eEncryptionStatus;
857 if (pDevice->eEncryptionStatus != Ndis802_11EncryptionDisabled)
858 pDevice->bEncryptionEnable = TRUE;
860 pDevice->bEncryptionEnable = FALSE;
862 if ((pMgmt->eAuthenMode == WMAC_AUTH_SHAREKEY) ||
863 ((pMgmt->eAuthenMode == WMAC_AUTH_OPEN) && (bwepEnabled==TRUE))) {
864 //mike re-comment:open-wep && sharekey-wep needn't do initial key!!
868 KeyvInitTable(pDevice,&pDevice->sKey);
870 spin_lock_irq(&pDevice->lock);
871 pDevice->bLinkPass = FALSE;
872 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
873 memset(pMgmt->abyCurrBSSID, 0, 6);
874 pMgmt->eCurrState = WMAC_STATE_IDLE;
875 netif_stop_queue(pDevice->dev);
877 //20080701-02,<Add> by Mike Liu
878 /*******search if ap_scan=2 ,which is associating request in hidden ssid mode ****/
880 PKnownBSS pCurr = NULL;
881 pCurr = BSSpSearchBSSList(pDevice,
882 pMgmt->abyDesireBSSID,
883 pMgmt->abyDesireSSID,
884 pDevice->eConfigPHYMode
888 printk("wpa_set_associate---->hidden mode site survey before associate.......\n");
889 bScheduleCommand((void *) pDevice,
891 pMgmt->abyDesireSSID);
894 /****************************************************************/
896 bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL);
897 spin_unlock_irq(&pDevice->lock);
905 * wpa_ioctl main function supported for wpa supplicant
917 int wpa_ioctl(PSDevice pDevice, struct iw_point *p)
919 struct viawget_wpa_param *param;
923 if (p->length < sizeof(struct viawget_wpa_param) ||
924 p->length > VIAWGET_WPA_MAX_BUF_SIZE || !p->pointer)
927 param = kmalloc((int)p->length, (int)GFP_KERNEL);
931 if (copy_from_user(param, p->pointer, p->length)) {
936 switch (param->cmd) {
937 case VIAWGET_SET_WPA:
938 ret = wpa_set_wpa(pDevice, param);
939 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_WPA \n");
942 case VIAWGET_SET_KEY:
943 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_KEY \n");
944 spin_lock_irq(&pDevice->lock);
945 ret = wpa_set_keys(pDevice, param, FALSE);
946 spin_unlock_irq(&pDevice->lock);
949 case VIAWGET_SET_SCAN:
950 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_SCAN \n");
951 ret = wpa_set_scan(pDevice, param);
954 case VIAWGET_GET_SCAN:
955 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_SCAN\n");
956 ret = wpa_get_scan(pDevice, param);
960 case VIAWGET_GET_SSID:
961 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_SSID \n");
962 ret = wpa_get_ssid(pDevice, param);
966 case VIAWGET_GET_BSSID:
967 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_BSSID \n");
968 ret = wpa_get_bssid(pDevice, param);
972 case VIAWGET_SET_ASSOCIATE:
973 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_ASSOCIATE \n");
974 ret = wpa_set_associate(pDevice, param);
977 case VIAWGET_SET_DISASSOCIATE:
978 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DISASSOCIATE \n");
979 ret = wpa_set_disassociate(pDevice, param);
982 case VIAWGET_SET_DROP_UNENCRYPT:
983 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DROP_UNENCRYPT \n");
986 case VIAWGET_SET_DEAUTHENTICATE:
987 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DEAUTHENTICATE \n");
991 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wpa_ioctl: unknown cmd=%d\n",
997 if ((ret == 0) && wpa_ioctl) {
998 if (copy_to_user(p->pointer, param, p->length)) {