SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/vt6656/wpactl.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   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.
   9  *
  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.
  14  *
  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.
  18  *
  19  *
  20  * File: wpactl.c
  21  *
  22  * Purpose: handle wpa supplicant ioctl input/out functions
  23  *
  24  * Author: Lyndon Chen
  25  *
  26  * Date: July 28, 2006
  27  *
  28  * Functions:
  29  *
  30  * Revision History:
  31  *
  32  */
  33
  34 #include "wpactl.h"
  35 #include "key.h"
  36 #include "mac.h"
  37 #include "device.h"
  38 #include "wmgr.h"
  39 #include "iocmd.h"
  40 #include "iowpa.h"
  41 #include "control.h"
  42 #include "rndis.h"
  43 #include "rf.h"
  44
  45 /*---------------------  Static Definitions -------------------------*/
  46
  47 #define VIAWGET_WPA_MAX_BUF_SIZE 1024
  48
  49
  50
  51 static const int frequency_list[] = {
  52         2412, 2417, 2422, 2427, 2432, 2437, 2442,
  53         2447, 2452, 2457, 2462, 2467, 2472, 2484
  54 };
  55 /*---------------------  Static Classes  ----------------------------*/
  56
  57 /*---------------------  Static Variables  --------------------------*/
  58 //static int          msglevel                =MSG_LEVEL_DEBUG;
  59 static int          msglevel                =MSG_LEVEL_INFO;
  60
  61 /*---------------------  Static Functions  --------------------------*/
  62
  63
  64
  65
  66 /*---------------------  Export Variables  --------------------------*/
  67 static void wpadev_setup(struct net_device *dev)
  68 {
  69         dev->type               = ARPHRD_IEEE80211;
  70         dev->hard_header_len    = ETH_HLEN;
  71         dev->mtu                = 2048;
  72         dev->addr_len           = ETH_ALEN;
  73         dev->tx_queue_len       = 1000;
  74
  75         memset(dev->broadcast,0xFF, ETH_ALEN);
  76
  77         dev->flags              = IFF_BROADCAST|IFF_MULTICAST;
  78 }
  79
  80 /*
  81  * Description:
  82  *      register netdev for wpa supplicant deamon
  83  *
  84  * Parameters:
  85  *  In:
  86  *      pDevice             -
  87  *      enable              -
  88  *  Out:
  89  *
  90  * Return Value:
  91  *
  92  */
  93
  94 static int wpa_init_wpadev(PSDevice pDevice)
  95 {
  96     PSDevice wpadev_priv;
  97         struct net_device *dev = pDevice->dev;
  98          int ret=0;
  99
 100         pDevice->wpadev = alloc_netdev(sizeof(PSDevice), "vntwpa", wpadev_setup);
 101         if (pDevice->wpadev == NULL)
 102                 return -ENOMEM;
 103
 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);
 112         if (ret) {
 113                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: register_netdev(WPA) failed!\n",
 114                        dev->name);
 115                 free_netdev(pDevice->wpadev);
 116                 return -1;
 117         }
 118
 119         if (pDevice->skb == NULL) {
 120         pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 121         if (pDevice->skb == NULL)
 122                     return -ENOMEM;
 123     }
 124
 125     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: Registered netdev %s for WPA management\n",
 126                dev->name, pDevice->wpadev->name);
 127
 128         return 0;
 129 }
 130
 131
 132 /*
 133  * Description:
 134  *      unregister net_device (wpadev)
 135  *
 136  * Parameters:
 137  *  In:
 138  *      pDevice             -
 139  *  Out:
 140  *
 141  * Return Value:
 142  *
 143  */
 144
 145 static int wpa_release_wpadev(PSDevice pDevice)
 146 {
 147     if (pDevice->skb) {
 148         dev_kfree_skb(pDevice->skb);
 149         pDevice->skb = NULL;
 150     }
 151
 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;
 158     }
 159
 160         return 0;
 161 }
 162
 163
 164
 165
 166
 167 /*
 168  * Description:
 169  *      Set enable/disable dev for wpa supplicant deamon
 170  *
 171  * Parameters:
 172  *  In:
 173  *      pDevice             -
 174  *      val                 -
 175  *  Out:
 176  *
 177  * Return Value:
 178  *
 179  */
 180
 181 int wpa_set_wpadev(PSDevice pDevice, int val)
 182 {
 183         if (val)
 184                 return wpa_init_wpadev(pDevice);
 185         else
 186                 return wpa_release_wpadev(pDevice);
 187 }
 188
 189
 190 /*
 191  * Description:
 192  *      Set WPA algorithm & keys
 193  *
 194  * Parameters:
 195  *  In:
 196  *      pDevice -
 197  *      param -
 198  *  Out:
 199  *
 200  * Return Value:
 201  *
 202  */
 203
 204  int wpa_set_keys(PSDevice pDevice, void *ctx, BOOL  fcpfkernel)
 205 {
 206     struct viawget_wpa_param *param=ctx;
 207     PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
 208     DWORD   dwKeyIndex = 0;
 209     BYTE    abyKey[MAX_KEY_LEN];
 210     BYTE    abySeq[MAX_KEY_LEN];
 211     QWORD   KeyRSC;
 212 //    NDIS_802_11_KEY_RSC KeyRSC;
 213     BYTE    byKeyDecMode = KEY_CTL_WEP;
 214         int ret = 0;
 215         int uu, ii;
 216
 217
 218         if (param->u.wpa_key.alg_name > WPA_ALG_CCMP)
 219                 return -EINVAL;
 220
 221     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "param->u.wpa_key.alg_name = %d \n", param->u.wpa_key.alg_name);
 222         if (param->u.wpa_key.alg_name == WPA_ALG_NONE) {
 223         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
 224         pDevice->bEncryptionEnable = FALSE;
 225         pDevice->byKeyIndex = 0;
 226         pDevice->bTransmitKey = FALSE;
 227         for (uu=0; uu<MAX_KEY_TABLE; uu++) {
 228             MACvDisableKeyEntry(pDevice, uu);
 229         }
 230         return ret;
 231     }
 232
 233     spin_unlock_irq(&pDevice->lock);
 234     if(param->u.wpa_key.key && fcpfkernel) {
 235        memcpy(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len);
 236      }
 237     else {
 238         if (param->u.wpa_key.key &&
 239             copy_from_user(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len)) {
 240             spin_lock_irq(&pDevice->lock);
 241             return -EINVAL;
 242         }
 243      }
 244     spin_lock_irq(&pDevice->lock);
 245
 246     dwKeyIndex = (DWORD)(param->u.wpa_key.key_index);
 247
 248         if (param->u.wpa_key.alg_name == WPA_ALG_WEP) {
 249         if (dwKeyIndex > 3) {
 250             return -EINVAL;
 251         }
 252         else {
 253             if (param->u.wpa_key.set_tx) {
 254                 pDevice->byKeyIndex = (BYTE)dwKeyIndex;
 255                 pDevice->bTransmitKey = TRUE;
 256                         dwKeyIndex |= (1 << 31);
 257             }
 258             KeybSetDefaultKey(  pDevice,
 259                                 &(pDevice->sKey),
 260                                 dwKeyIndex & ~(BIT30 | USE_KEYRSC),
 261                                 param->u.wpa_key.key_len,
 262                                 NULL,
 263                                 abyKey,
 264                                 KEY_CTL_WEP
 265                               );
 266
 267         }
 268         pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
 269         pDevice->bEncryptionEnable = TRUE;
 270         return ret;
 271         }
 272
 273     spin_unlock_irq(&pDevice->lock);
 274         if(param->u.wpa_key.seq && fcpfkernel) {
 275            memcpy(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len);
 276                 }
 277        else {
 278         if (param->u.wpa_key.seq &&
 279             copy_from_user(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len)) {
 280             spin_lock_irq(&pDevice->lock);
 281             return -EINVAL;
 282         }
 283         }
 284         spin_lock_irq(&pDevice->lock);
 285
 286         if (param->u.wpa_key.seq_len > 0) {
 287                 for (ii = 0 ; ii < param->u.wpa_key.seq_len ; ii++) {
 288                      if (ii < 4)
 289                             LODWORD(KeyRSC) |= (abySeq[ii] << (ii * 8));
 290                          else
 291                             HIDWORD(KeyRSC) |= (abySeq[ii] << ((ii-4) * 8));
 292                  //KeyRSC |= (abySeq[ii] << (ii * 8));
 293                 }
 294                 dwKeyIndex |= 1 << 29;
 295         }
 296
 297     if (param->u.wpa_key.key_index >= MAX_GROUP_KEY) {
 298         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return  dwKeyIndex > 3\n");
 299         return -EINVAL;
 300     }
 301
 302         if (param->u.wpa_key.alg_name == WPA_ALG_TKIP) {
 303         pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
 304     }
 305
 306         if (param->u.wpa_key.alg_name == WPA_ALG_CCMP) {
 307         pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
 308     }
 309
 310         if (param->u.wpa_key.set_tx)
 311                 dwKeyIndex |= (1 << 31);
 312
 313
 314     if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)
 315         byKeyDecMode = KEY_CTL_CCMP;
 316     else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
 317         byKeyDecMode = KEY_CTL_TKIP;
 318     else
 319         byKeyDecMode = KEY_CTL_WEP;
 320
 321     // Fix HCT test that set 256 bits KEY and Ndis802_11Encryption3Enabled
 322     if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
 323         if (param->u.wpa_key.key_len == MAX_KEY_LEN)
 324             byKeyDecMode = KEY_CTL_TKIP;
 325         else if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
 326             byKeyDecMode = KEY_CTL_WEP;
 327         else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
 328             byKeyDecMode = KEY_CTL_WEP;
 329     } else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
 330         if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
 331             byKeyDecMode = KEY_CTL_WEP;
 332         else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
 333             byKeyDecMode = KEY_CTL_WEP;
 334     }
 335
 336     // Check TKIP key length
 337     if ((byKeyDecMode == KEY_CTL_TKIP) &&
 338         (param->u.wpa_key.key_len != MAX_KEY_LEN)) {
 339         // TKIP Key must be 256 bits
 340         //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - TKIP Key must be 256 bits\n"));
 341         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return- TKIP Key must be 256 bits!\n");
 342         return -EINVAL;
 343     }
 344     // Check AES key length
 345     if ((byKeyDecMode == KEY_CTL_CCMP) &&
 346         (param->u.wpa_key.key_len != AES_KEY_LEN)) {
 347         // AES Key must be 128 bits
 348         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return - AES Key must be 128 bits\n");
 349         return -EINVAL;
 350     }
 351
 352
 353     if (IS_BROADCAST_ADDRESS(&param->addr[0]) || (param->addr == NULL)) {
 354         // If IS_BROADCAST_ADDRESS, set the key as every key entry's group key.
 355         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Groupe Key Assign.\n");
 356
 357         if ((KeybSetAllGroupKey(pDevice,
 358                             &(pDevice->sKey),
 359                             dwKeyIndex,
 360                             param->u.wpa_key.key_len,
 361                             (PQWORD) &(KeyRSC),
 362                             (PBYTE)abyKey,
 363                             byKeyDecMode
 364                             ) == TRUE) &&
 365             (KeybSetDefaultKey(pDevice,
 366                             &(pDevice->sKey),
 367                             dwKeyIndex,
 368                             param->u.wpa_key.key_len,
 369                             (PQWORD) &(KeyRSC),
 370                             (PBYTE)abyKey,
 371                             byKeyDecMode
 372                             ) == TRUE) ) {
 373              DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GROUP Key Assign.\n");
 374
 375         } else {
 376             //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -KeybSetDefaultKey Fail.0\n"));
 377             return -EINVAL;
 378         }
 379
 380     } else {
 381         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Assign.\n");
 382         // BSSID not 0xffffffffffff
 383         // Pairwise Key can't be WEP
 384         if (byKeyDecMode == KEY_CTL_WEP) {
 385             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key can't be WEP\n");
 386             return -EINVAL;
 387         }
 388
 389         dwKeyIndex |= (1 << 30); // set pairwise key
 390         if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
 391             //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - WMAC_CONFIG_IBSS_STA\n"));
 392             return -EINVAL;
 393         }
 394         if (KeybSetKey(pDevice,
 395                        &(pDevice->sKey),
 396                        &param->addr[0],
 397                        dwKeyIndex,
 398                        param->u.wpa_key.key_len,
 399                        (PQWORD) &(KeyRSC),
 400                        (PBYTE)abyKey,
 401                         byKeyDecMode
 402                        ) == TRUE) {
 403             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Set\n");
 404
 405         } else {
 406             // Key Table Full
 407             if (IS_ETH_ADDRESS_EQUAL(&param->addr[0], pDevice->abyBSSID)) {
 408                 //DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -Key Table Full.2\n"));
 409                 return -EINVAL;
 410
 411             } else {
 412                 // Save Key and configure just before associate/reassociate to BSSID
 413                 // we do not implement now
 414                 return -EINVAL;
 415             }
 416         }
 417     } // BSSID not 0xffffffffffff
 418     if ((ret == 0) && ((param->u.wpa_key.set_tx) != 0)) {
 419         pDevice->byKeyIndex = (BYTE)param->u.wpa_key.key_index;
 420         pDevice->bTransmitKey = TRUE;
 421     }
 422     pDevice->bEncryptionEnable = TRUE;
 423
 424 /*
 425     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " key=%x-%x-%x-%x-%x-xxxxx \n",
 426                pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][0],
 427                pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][1],
 428                pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][2],
 429                pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][3],
 430                pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][4]
 431               );
 432 */
 433
 434         return ret;
 435
 436 }
 437
 438
 439 /*
 440  * Description:
 441  *      enable wpa auth & mode
 442  *
 443  * Parameters:
 444  *  In:
 445  *      pDevice   -
 446  *      param     -
 447  *  Out:
 448  *
 449  * Return Value:
 450  *
 451  */
 452
 453 static int wpa_set_wpa(PSDevice pDevice,
 454                                      struct viawget_wpa_param *param)
 455 {
 456
 457     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 458         int ret = 0;
 459
 460     pMgmt->eAuthenMode = WMAC_AUTH_OPEN;
 461     pMgmt->bShareKeyAlgorithm = FALSE;
 462
 463     return ret;
 464 }
 465
 466
 467
 468
 469  /*
 470  * Description:
 471  *      set disassociate
 472  *
 473  * Parameters:
 474  *  In:
 475  *      pDevice   -
 476  *      param     -
 477  *  Out:
 478  *
 479  * Return Value:
 480  *
 481  */
 482
 483 static int wpa_set_disassociate(PSDevice pDevice,
 484                                      struct viawget_wpa_param *param)
 485 {
 486     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 487         int ret = 0;
 488
 489     spin_lock_irq(&pDevice->lock);
 490     if (pDevice->bLinkPass) {
 491         if (!memcmp(param->addr, pMgmt->abyCurrBSSID, 6))
 492                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
 493     }
 494     spin_unlock_irq(&pDevice->lock);
 495
 496     return ret;
 497 }
 498
 499
 500
 501 /*
 502  * Description:
 503  *      enable scan process
 504  *
 505  * Parameters:
 506  *  In:
 507  *      pDevice   -
 508  *      param     -
 509  *  Out:
 510  *
 511  * Return Value:
 512  *
 513  */
 514
 515 static int wpa_set_scan(PSDevice pDevice,
 516                         struct viawget_wpa_param *param)
 517 {
 518         int ret = 0;
 519
 520 //2007-0919-01<Add>by MikeLiu
 521 /**set ap_scan=1&&scan_ssid=1 under hidden ssid mode**/
 522         PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
 523         PWLAN_IE_SSID       pItemSSID;
 524 printk("wpa_set_scan-->desired [ssid=%s,ssid_len=%d]\n",
 525              param->u.scan_req.ssid,param->u.scan_req.ssid_len);
 526 // Set the SSID
 527 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
 528 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
 529 pItemSSID->byElementID = WLAN_EID_SSID;
 530 memcpy(pItemSSID->abySSID, param->u.scan_req.ssid, param->u.scan_req.ssid_len);
 531 pItemSSID->len = param->u.scan_req.ssid_len;
 532
 533     spin_lock_irq(&pDevice->lock);
 534     BSSvClearBSSList((void *) pDevice, pDevice->bLinkPass);
 535     /* bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL); */
 536     bScheduleCommand((void *) pDevice,
 537                      WLAN_CMD_BSSID_SCAN,
 538                      pMgmt->abyDesireSSID);
 539     spin_unlock_irq(&pDevice->lock);
 540
 541     return ret;
 542 }
 543
 544
 545
 546 /*
 547  * Description:
 548  *      get bssid
 549  *
 550  * Parameters:
 551  *  In:
 552  *      pDevice   -
 553  *      param     -
 554  *  Out:
 555  *
 556  * Return Value:
 557  *
 558  */
 559
 560 static int wpa_get_bssid(PSDevice pDevice,
 561                                      struct viawget_wpa_param *param)
 562 {
 563     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
 564         int ret = 0;
 565         memcpy(param->u.wpa_associate.bssid, pMgmt->abyCurrBSSID , 6);
 566
 567     return ret;
 568
 569 }
 570
 571
 572 /*
 573  * Description:
 574  *      get bssid
 575  *
 576  * Parameters:
 577  *  In:
 578  *      pDevice   -
 579  *      param     -
 580  *  Out:
 581  *
 582  * Return Value:
 583  *
 584  */
 585
 586 static int wpa_get_ssid(PSDevice pDevice,
 587                                      struct viawget_wpa_param *param)
 588 {
 589     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
 590         PWLAN_IE_SSID       pItemSSID;
 591         int ret = 0;
 592
 593     pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
 594
 595         memcpy(param->u.wpa_associate.ssid, pItemSSID->abySSID , pItemSSID->len);
 596         param->u.wpa_associate.ssid_len = pItemSSID->len;
 597
 598     return ret;
 599 }
 600
 601
 602
 603 /*
 604  * Description:
 605  *      get scan results
 606  *
 607  * Parameters:
 608  *  In:
 609  *      pDevice   -
 610  *      param     -
 611  *  Out:
 612  *
 613  * Return Value:
 614  *
 615  */
 616
 617 static int wpa_get_scan(PSDevice pDevice,
 618                                      struct viawget_wpa_param *param)
 619 {
 620         struct viawget_scan_result *scan_buf;
 621     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 622     PWLAN_IE_SSID   pItemSSID;
 623     PKnownBSS pBSS;
 624         PBYTE  pBuf;
 625         int ret = 0;
 626         u16 count = 0;
 627         u16 ii, jj;
 628         long ldBm;//James //add
 629
 630 //******mike:bubble sort by stronger RSSI*****//
 631
 632     PBYTE ptempBSS;
 633
 634
 635
 636     ptempBSS = kmalloc(sizeof(KnownBSS), (int)GFP_ATOMIC);
 637
 638     if (ptempBSS == NULL) {
 639
 640        printk("bubble sort kmalloc memory fail@@@\n");
 641
 642         ret = -ENOMEM;
 643
 644         return ret;
 645
 646     }
 647
 648     for (ii = 0; ii < MAX_BSS_NUM; ii++) {
 649
 650          for(jj=0;jj<MAX_BSS_NUM-ii-1;jj++) {
 651
 652            if((pMgmt->sBSSList[jj].bActive!=TRUE) ||
 653
 654                 ((pMgmt->sBSSList[jj].uRSSI>pMgmt->sBSSList[jj+1].uRSSI) &&(pMgmt->sBSSList[jj+1].bActive!=FALSE))) {
 655
 656                  memcpy(ptempBSS,&pMgmt->sBSSList[jj],sizeof(KnownBSS));
 657
 658                  memcpy(&pMgmt->sBSSList[jj],&pMgmt->sBSSList[jj+1],sizeof(KnownBSS));
 659
 660                  memcpy(&pMgmt->sBSSList[jj+1],ptempBSS,sizeof(KnownBSS));
 661
 662               }
 663
 664          }
 665
 666     };
 667
 668   kfree(ptempBSS);
 669
 670  // printk("bubble sort result:\n");
 671
 672         count = 0;
 673         pBSS = &(pMgmt->sBSSList[0]);
 674     for (ii = 0; ii < MAX_BSS_NUM; ii++) {
 675         pBSS = &(pMgmt->sBSSList[ii]);
 676         if (!pBSS->bActive)
 677             continue;
 678         count++;
 679     };
 680
 681     pBuf = kmalloc(sizeof(struct viawget_scan_result) * count, (int)GFP_ATOMIC);
 682
 683     if (pBuf == NULL) {
 684         ret = -ENOMEM;
 685         return ret;
 686     }
 687         memset(pBuf, 0, sizeof(struct viawget_scan_result) * count);
 688     scan_buf = (struct viawget_scan_result *)pBuf;
 689         pBSS = &(pMgmt->sBSSList[0]);
 690     for (ii = 0, jj = 0; ii < MAX_BSS_NUM ; ii++) {
 691         pBSS = &(pMgmt->sBSSList[ii]);
 692         if (pBSS->bActive) {
 693             if (jj >= count)
 694                 break;
 695             memcpy(scan_buf->bssid, pBSS->abyBSSID, WLAN_BSSID_LEN);
 696             pItemSSID = (PWLAN_IE_SSID)pBSS->abySSID;
 697                     memcpy(scan_buf->ssid, pItemSSID->abySSID, pItemSSID->len);
 698                     scan_buf->ssid_len = pItemSSID->len;
 699             scan_buf->freq = frequency_list[pBSS->uChannel-1];
 700             scan_buf->caps = pBSS->wCapInfo;    //DavidWang for sharemode
 701 //20080717-05,<Add> by James Li
 702                 RFvRSSITodBm(pDevice, (BYTE)(pBSS->uRSSI), &ldBm);
 703                         if(-ldBm<50){
 704                                 scan_buf->qual = 100;
 705                         }else  if(-ldBm > 90) {
 706                                  scan_buf->qual = 0;
 707                         }else {
 708                                 scan_buf->qual=(40-(-ldBm-50))*100/40;
 709                         }
 710
 711                         //James
 712             //scan_buf->caps = pBSS->wCapInfo;
 713             //scan_buf->qual =
 714             scan_buf->noise = 0;
 715             scan_buf->level = ldBm;
 716  //20080717-05,<Add> by James Li--End
 717             //scan_buf->maxrate =
 718             if (pBSS->wWPALen != 0) {
 719                 scan_buf->wpa_ie_len = pBSS->wWPALen;
 720                 memcpy(scan_buf->wpa_ie, pBSS->byWPAIE, pBSS->wWPALen);
 721             }
 722             if (pBSS->wRSNLen != 0) {
 723                 scan_buf->rsn_ie_len = pBSS->wRSNLen;
 724                 memcpy(scan_buf->rsn_ie, pBSS->byRSNIE, pBSS->wRSNLen);
 725             }
 726             scan_buf = (struct viawget_scan_result *)((PBYTE)scan_buf + sizeof(struct viawget_scan_result));
 727             jj ++;
 728         }
 729     }
 730
 731     if (jj < count)
 732         count = jj;
 733
 734     if (copy_to_user(param->u.scan_results.buf, pBuf, sizeof(struct viawget_scan_result) * count)) {
 735                 ret = -EFAULT;
 736         };
 737         param->u.scan_results.scan_count = count;
 738     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " param->u.scan_results.scan_count = %d\n", count)
 739
 740     kfree(pBuf);
 741     return ret;
 742 }
 743
 744
 745
 746 /*
 747  * Description:
 748  *      set associate with AP
 749  *
 750  * Parameters:
 751  *  In:
 752  *      pDevice   -
 753  *      param     -
 754  *  Out:
 755  *
 756  * Return Value:
 757  *
 758  */
 759
 760 static int wpa_set_associate(PSDevice pDevice,
 761                                      struct viawget_wpa_param *param)
 762 {
 763     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 764     PWLAN_IE_SSID   pItemSSID;
 765     BYTE    abyNullAddr[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 766     BYTE    abyWPAIE[64];
 767     int ret = 0;
 768     BOOL   bwepEnabled=FALSE;
 769
 770         // set key type & algorithm
 771     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pairwise_suite = %d\n", param->u.wpa_associate.pairwise_suite);
 772     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "group_suite = %d\n", param->u.wpa_associate.group_suite);
 773     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "key_mgmt_suite = %d\n", param->u.wpa_associate.key_mgmt_suite);
 774     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "auth_alg = %d\n", param->u.wpa_associate.auth_alg);
 775     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "mode = %d\n", param->u.wpa_associate.mode);
 776     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wpa_ie_len = %d\n", param->u.wpa_associate.wpa_ie_len);
 777     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Roaming dBm = %d\n", param->u.wpa_associate.roam_dbm);  //Davidwang
 778
 779         if (param->u.wpa_associate.wpa_ie &&
 780             copy_from_user(&abyWPAIE[0], param->u.wpa_associate.wpa_ie, param->u.wpa_associate.wpa_ie_len))
 781             return -EINVAL;
 782
 783         if (param->u.wpa_associate.mode == 1)
 784             pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
 785         else
 786             pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
 787
 788         // set bssid
 789     if (memcmp(param->u.wpa_associate.bssid, &abyNullAddr[0], 6) != 0)
 790         memcpy(pMgmt->abyDesireBSSID, param->u.wpa_associate.bssid, 6);
 791     // set ssid
 792         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
 793     pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
 794     pItemSSID->byElementID = WLAN_EID_SSID;
 795         pItemSSID->len = param->u.wpa_associate.ssid_len;
 796         memcpy(pItemSSID->abySSID, param->u.wpa_associate.ssid, pItemSSID->len);
 797
 798     if (param->u.wpa_associate.wpa_ie_len == 0) {
 799             if (param->u.wpa_associate.auth_alg & AUTH_ALG_SHARED_KEY)
 800             pMgmt->eAuthenMode = WMAC_AUTH_SHAREKEY;
 801             else
 802             pMgmt->eAuthenMode = WMAC_AUTH_OPEN;
 803         } else if (abyWPAIE[0] == RSN_INFO_ELEM) {
 804                 if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_PSK)
 805                         pMgmt->eAuthenMode = WMAC_AUTH_WPA2PSK;
 806                 else
 807                         pMgmt->eAuthenMode = WMAC_AUTH_WPA2;
 808         } else {
 809                 if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_WPA_NONE)
 810                         pMgmt->eAuthenMode = WMAC_AUTH_WPANONE;
 811                 else if (param->u.wpa_associate.key_mgmt_suite == KEY_MGMT_PSK)
 812                     pMgmt->eAuthenMode = WMAC_AUTH_WPAPSK;
 813                 else
 814                     pMgmt->eAuthenMode = WMAC_AUTH_WPA;
 815         }
 816
 817         switch (param->u.wpa_associate.pairwise_suite) {
 818         case CIPHER_CCMP:
 819                 pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
 820                 break;
 821         case CIPHER_TKIP:
 822                 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
 823                 break;
 824         case CIPHER_WEP40:
 825         case CIPHER_WEP104:
 826                 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
 827                 bwepEnabled = TRUE;
 828         //      printk("****************wpa_set_associate:set CIPHER_WEP40_104\n");
 829                 break;
 830         case CIPHER_NONE:
 831                 if (param->u.wpa_associate.group_suite == CIPHER_CCMP)
 832                         pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
 833                 else
 834                         pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
 835                 break;
 836         default:
 837                 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
 838         };
 839
 840            pMgmt->Roam_dbm = param->u.wpa_associate.roam_dbm;
 841          // if ((pMgmt->Roam_dbm > 40)&&(pMgmt->Roam_dbm<80))
 842          //    pDevice->bEnableRoaming = TRUE;
 843
 844             if (pMgmt->eAuthenMode == WMAC_AUTH_SHAREKEY) {   //@wep-sharekey
 845             pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
 846             pMgmt->bShareKeyAlgorithm = TRUE;
 847              }
 848             else if (pMgmt->eAuthenMode == WMAC_AUTH_OPEN) {
 849                if(bwepEnabled==TRUE) {                                                         //@open-wep
 850                        pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
 851                 }
 852               else {                                                                                                 //@only open
 853             pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
 854                 }
 855            }
 856 //mike save old encryption status
 857         pDevice->eOldEncryptionStatus = pDevice->eEncryptionStatus;
 858
 859     if (pDevice->eEncryptionStatus !=  Ndis802_11EncryptionDisabled)
 860         pDevice->bEncryptionEnable = TRUE;
 861     else
 862         pDevice->bEncryptionEnable = FALSE;
 863
 864  if ((pMgmt->eAuthenMode == WMAC_AUTH_SHAREKEY) ||
 865       ((pMgmt->eAuthenMode == WMAC_AUTH_OPEN) && (bwepEnabled==TRUE)))  {
 866  //mike re-comment:open-wep && sharekey-wep needn't do initial key!!
 867
 868      }
 869  else
 870     KeyvInitTable(pDevice,&pDevice->sKey);
 871
 872     spin_lock_irq(&pDevice->lock);
 873     pDevice->bLinkPass = FALSE;
 874     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 875     memset(pMgmt->abyCurrBSSID, 0, 6);
 876     pMgmt->eCurrState = WMAC_STATE_IDLE;
 877     netif_stop_queue(pDevice->dev);
 878
 879 //20080701-02,<Add> by Mike Liu
 880 /*******search if ap_scan=2 ,which is associating request in hidden ssid mode ****/
 881 {
 882    PKnownBSS       pCurr = NULL;
 883     pCurr = BSSpSearchBSSList(pDevice,
 884                               pMgmt->abyDesireBSSID,
 885                               pMgmt->abyDesireSSID,
 886                               pDevice->eConfigPHYMode
 887                               );
 888
 889     if (pCurr == NULL){
 890     printk("wpa_set_associate---->hidden mode site survey before associate.......\n");
 891     bScheduleCommand((void *) pDevice,
 892                      WLAN_CMD_BSSID_SCAN,
 893                      pMgmt->abyDesireSSID);
 894   };
 895 }
 896 /****************************************************************/
 897
 898     bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL);
 899     spin_unlock_irq(&pDevice->lock);
 900
 901     return ret;
 902 }
 903
 904
 905 /*
 906  * Description:
 907  *      wpa_ioctl main function supported for wpa supplicant
 908  *
 909  * Parameters:
 910  *  In:
 911  *      pDevice   -
 912  *      iw_point  -
 913  *  Out:
 914  *
 915  * Return Value:
 916  *
 917  */
 918
 919 int wpa_ioctl(PSDevice pDevice, struct iw_point *p)
 920 {
 921         struct viawget_wpa_param *param;
 922         int ret = 0;
 923         int wpa_ioctl = 0;
 924
 925         if (p->length < sizeof(struct viawget_wpa_param) ||
 926             p->length > VIAWGET_WPA_MAX_BUF_SIZE || !p->pointer)
 927                 return -EINVAL;
 928
 929         param = kmalloc((int)p->length, (int)GFP_KERNEL);
 930         if (param == NULL)
 931                 return -ENOMEM;
 932
 933         if (copy_from_user(param, p->pointer, p->length)) {
 934                 ret = -EFAULT;
 935                 goto out;
 936         }
 937
 938         switch (param->cmd) {
 939         case VIAWGET_SET_WPA:
 940         ret = wpa_set_wpa(pDevice, param);
 941             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_WPA \n");
 942                 break;
 943
 944         case VIAWGET_SET_KEY:
 945             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_KEY \n");
 946             spin_lock_irq(&pDevice->lock);
 947         ret = wpa_set_keys(pDevice, param, FALSE);
 948         spin_unlock_irq(&pDevice->lock);
 949                 break;
 950
 951         case VIAWGET_SET_SCAN:
 952             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_SCAN \n");
 953         ret = wpa_set_scan(pDevice, param);
 954                 break;
 955
 956         case VIAWGET_GET_SCAN:
 957             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_SCAN\n");
 958         ret = wpa_get_scan(pDevice, param);
 959                 wpa_ioctl = 1;
 960                 break;
 961
 962         case VIAWGET_GET_SSID:
 963             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_SSID \n");
 964         ret = wpa_get_ssid(pDevice, param);
 965                 wpa_ioctl = 1;
 966                 break;
 967
 968         case VIAWGET_GET_BSSID:
 969             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_GET_BSSID \n");
 970         ret = wpa_get_bssid(pDevice, param);
 971                 wpa_ioctl = 1;
 972                 break;
 973
 974         case VIAWGET_SET_ASSOCIATE:
 975             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_ASSOCIATE \n");
 976         ret = wpa_set_associate(pDevice, param);
 977                 break;
 978
 979         case VIAWGET_SET_DISASSOCIATE:
 980             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DISASSOCIATE \n");
 981         ret = wpa_set_disassociate(pDevice, param);
 982                 break;
 983
 984         case VIAWGET_SET_DROP_UNENCRYPT:
 985             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DROP_UNENCRYPT \n");
 986                 break;
 987
 988     case VIAWGET_SET_DEAUTHENTICATE:
 989             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_SET_DEAUTHENTICATE \n");
 990                 break;
 991
 992         default:
 993             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wpa_ioctl: unknown cmd=%d\n",
 994                        param->cmd);
 995                 return -EOPNOTSUPP;
 996                 break;
 997         }
 998
 999         if ((ret == 0) && wpa_ioctl) {
1000                 if (copy_to_user(p->pointer, param, p->length)) {
1001                         ret = -EFAULT;
1002                         goto out;
1003                 }
1004         }
1005
1006 out:
1007         if (param != NULL)
1008                 kfree(param);
1009
1010         return ret;
1011 }
1012