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