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