SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/vt6656/ioctl.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  * File: ioctl.c
  20  *
  21  * Purpose:  private ioctl functions
  22  *
  23  * Author: Lyndon Chen
  24  *
  25  * Date: Auguest 20, 2003
  26  *
  27  * Functions:
  28  *
  29  * Revision History:
  30  *
  31  */
  32
  33 #include "ioctl.h"
  34 #include "iocmd.h"
  35 #include "mac.h"
  36 #include "card.h"
  37 #include "hostap.h"
  38 #include "umem.h"
  39 #include "wpactl.h"
  40 #include "control.h"
  41 #include "rndis.h"
  42 #include "rf.h"
  43
  44 /*---------------------  Static Definitions -------------------------*/
  45
  46 /*---------------------  Static Classes  ----------------------------*/
  47
  48 /*---------------------  Static Variables  --------------------------*/
  49 //static int          msglevel                =MSG_LEVEL_DEBUG;
  50 static int          msglevel                =MSG_LEVEL_INFO;
  51
  52 #ifdef WPA_SM_Transtatus
  53     SWPAResult wpa_Result;
  54 #endif
  55
  56 /*---------------------  Static Functions  --------------------------*/
  57
  58 /*---------------------  Export Variables  --------------------------*/
  59
  60 int private_ioctl(PSDevice pDevice, struct ifreq *rq) {
  61
  62         PSCmdRequest        pReq = (PSCmdRequest)rq;
  63     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
  64         int                     result = 0;
  65     PWLAN_IE_SSID       pItemSSID;
  66     SCmdBSSJoin         sJoinCmd;
  67     SCmdZoneTypeSet sZoneTypeCmd;
  68     SCmdScan            sScanCmd;
  69     SCmdStartAP         sStartAPCmd;
  70     SCmdSetWEP          sWEPCmd;
  71     SCmdValue           sValue;
  72     SBSSIDList          sList;
  73     SNodeList           sNodeList;
  74     PSBSSIDList         pList;
  75     PSNodeList          pNodeList;
  76     UINT                cbListCount;
  77     PKnownBSS           pBSS;
  78     PKnownNodeDB        pNode;
  79     UINT                ii, jj;
  80     SCmdLinkStatus      sLinkStatus;
  81     BYTE                abySuppRates[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16};
  82     BYTE                abyNullAddr[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  83     DWORD               dwKeyIndex= 0;
  84     BYTE                abyScanSSID[WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1];
  85     LONG                ldBm;
  86
  87     pReq->wResult = 0;
  88
  89     switch(pReq->wCmdCode) {
  90
  91     case WLAN_CMD_BSS_SCAN:
  92
  93         if (copy_from_user(&sScanCmd, pReq->data, sizeof(SCmdScan))) {
  94                         result = -EFAULT;
  95                         break;
  96                 };
  97
  98         pItemSSID = (PWLAN_IE_SSID)sScanCmd.ssid;
  99         if (pItemSSID->len != 0) {
 100             memset(abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
 101             memcpy(abyScanSSID, pItemSSID, pItemSSID->len + WLAN_IEHDR_LEN);
 102         }
 103         spin_lock_irq(&pDevice->lock);
 104         if (memcmp(pMgmt->abyCurrBSSID, &abyNullAddr[0], 6) == 0)
 105             BSSvClearBSSList((HANDLE)pDevice, FALSE);
 106         else
 107             BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
 108         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_BSS_SCAN..begin \n");
 109
 110         if (pItemSSID->len != 0)
 111             bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, abyScanSSID);
 112         else
 113             bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
 114         spin_unlock_irq(&pDevice->lock);
 115         break;
 116
 117     case WLAN_CMD_ZONETYPE_SET:
 118         //mike add :cann't support.
 119            result=-EOPNOTSUPP;
 120           break;
 121
 122         if (copy_from_user(&sZoneTypeCmd, pReq->data, sizeof(SCmdZoneTypeSet))) {
 123                         result = -EFAULT;
 124                         break;
 125                 };
 126
 127           if(sZoneTypeCmd.bWrite==TRUE) {
 128           //////write zonetype
 129                 if(sZoneTypeCmd.ZoneType == ZoneType_USA) {
 130                   //set to USA
 131                    printk("set_ZoneType:USA\n");
 132                 }
 133                 else if(sZoneTypeCmd.ZoneType == ZoneType_Japan) {
 134                   //set to Japan
 135                   printk("set_ZoneType:Japan\n");
 136                 }
 137                else if(sZoneTypeCmd.ZoneType == ZoneType_Europe) {
 138                   //set to Europe
 139                   printk("set_ZoneType:Europe\n");
 140                 }
 141             }
 142         else {
 143           ///////read zonetype
 144           BYTE                       zonetype=0;
 145
 146
 147            if(zonetype == 0x00)  { //USA
 148              sZoneTypeCmd.ZoneType = ZoneType_USA;
 149            }
 150          else if(zonetype == 0x01) { //Japan
 151              sZoneTypeCmd.ZoneType = ZoneType_Japan;
 152           }
 153          else if(zonetype == 0x02) { //Europe
 154              sZoneTypeCmd.ZoneType = ZoneType_Europe;
 155          }
 156          else { //Unknow ZoneType
 157                 printk("Error:ZoneType[%x] Unknown ???\n",zonetype);
 158                  result = -EFAULT;
 159                 break;
 160          }
 161            if (copy_to_user(pReq->data, &sZoneTypeCmd, sizeof(SCmdZoneTypeSet))) {
 162                         result = -EFAULT;
 163                         break;
 164                 };
 165         }
 166
 167              break;
 168
 169     case WLAN_CMD_BSS_JOIN:
 170
 171         if (copy_from_user(&sJoinCmd, pReq->data, sizeof(SCmdBSSJoin))) {
 172                         result = -EFAULT;
 173                         break;
 174                 };
 175
 176         pItemSSID = (PWLAN_IE_SSID)sJoinCmd.ssid;
 177         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
 178                 memcpy(pMgmt->abyDesireSSID, pItemSSID, pItemSSID->len + WLAN_IEHDR_LEN);
 179             if (sJoinCmd.wBSSType == ADHOC) {
 180                 pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
 181                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct set to adhoc mode\n");
 182             }
 183             else {
 184                 pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
 185                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct set to STA mode\n");
 186             }
 187             if (sJoinCmd.bPSEnable == TRUE) {
 188             pDevice->ePSMode = WMAC_POWER_FAST;
 189 //            pDevice->ePSMode = WMAC_POWER_MAX;
 190             pMgmt->wListenInterval = 2;
 191             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Power Saving On\n");
 192         }
 193         else {
 194             pDevice->ePSMode = WMAC_POWER_CAM;
 195             pMgmt->wListenInterval = 1;
 196             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Power Saving Off \n");
 197         }
 198
 199         if (sJoinCmd.bShareKeyAuth == TRUE){
 200             pMgmt->bShareKeyAlgorithm = TRUE;
 201             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Share Key \n");
 202         }
 203         else {
 204             pMgmt->bShareKeyAlgorithm = FALSE;
 205             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Open System \n");
 206         }
 207             pDevice->uChannel = sJoinCmd.uChannel;
 208         netif_stop_queue(pDevice->dev);
 209         spin_lock_irq(&pDevice->lock);
 210         pMgmt->eCurrState = WMAC_STATE_IDLE;
 211         bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
 212         bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
 213         spin_unlock_irq(&pDevice->lock);
 214         break;
 215
 216     case WLAN_CMD_SET_WEP:
 217         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_WEP Key. \n");
 218         memset(&sWEPCmd, 0 ,sizeof(SCmdSetWEP));
 219         if (copy_from_user(&sWEPCmd, pReq->data, sizeof(SCmdSetWEP))) {
 220                         result = -EFAULT;
 221                         break;
 222                 };
 223             if (sWEPCmd.bEnableWep != TRUE) {
 224                 int uu;
 225
 226             pDevice->bEncryptionEnable = FALSE;
 227             pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
 228             spin_lock_irq(&pDevice->lock);
 229             for(uu=0;uu<MAX_KEY_TABLE;uu++)
 230                 MACvDisableKeyEntry(pDevice,uu);
 231             spin_unlock_irq(&pDevice->lock);
 232             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WEP function disable. \n");
 233             break;
 234         }
 235
 236         for (ii = 0; ii < WLAN_WEP_NKEYS; ii ++) {
 237             if (sWEPCmd.bWepKeyAvailable[ii]) {
 238                 if (ii == sWEPCmd.byKeyIndex)
 239 //2006-1207-01<Modify>by Einsn Liu
 240 //                  dwKeyIndex|= (1 << 31);
 241                     dwKeyIndex=ii|(1 << 31);
 242                 else
 243                     dwKeyIndex = ii;
 244                 spin_lock_irq(&pDevice->lock);
 245                 KeybSetDefaultKey(  pDevice,
 246                                     &(pDevice->sKey),
 247                                     dwKeyIndex,
 248                                     sWEPCmd.auWepKeyLength[ii],
 249                                     NULL,
 250                                     (PBYTE)&sWEPCmd.abyWepKey[ii][0],
 251                                     KEY_CTL_WEP
 252                                   );
 253                spin_unlock_irq(&pDevice->lock);
 254
 255             }
 256         }
 257         pDevice->byKeyIndex = sWEPCmd.byKeyIndex;
 258         pDevice->bTransmitKey = TRUE;
 259         pDevice->bEncryptionEnable = TRUE;
 260         pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
 261
 262         break;
 263
 264     case WLAN_CMD_GET_LINK:
 265         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_GET_LINK status. \n");
 266
 267         memset(sLinkStatus.abySSID, 0 , WLAN_SSID_MAXLEN + 1);
 268
 269         if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA)
 270             sLinkStatus.wBSSType = ADHOC;
 271         else
 272             sLinkStatus.wBSSType = INFRA;
 273
 274         if (pMgmt->eCurrState == WMAC_STATE_JOINTED)
 275             sLinkStatus.byState = ADHOC_JOINTED;
 276         else
 277             sLinkStatus.byState = ADHOC_STARTED;
 278
 279         sLinkStatus.uChannel = pMgmt->uCurrChannel;
 280         if (pDevice->bLinkPass == TRUE) {
 281             sLinkStatus.bLink = TRUE;
 282                     pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
 283                     memcpy(sLinkStatus.abySSID, pItemSSID->abySSID, pItemSSID->len);
 284                     memcpy(sLinkStatus.abyBSSID, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
 285                     sLinkStatus.uLinkRate = pMgmt->sNodeDBTable[0].wTxDataRate;
 286             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Link Success ! \n");
 287         }
 288         else {
 289             sLinkStatus.bLink = FALSE;
 290         }
 291         if (copy_to_user(pReq->data, &sLinkStatus, sizeof(SCmdLinkStatus))) {
 292                         result = -EFAULT;
 293                         break;
 294                 };
 295
 296         break;
 297
 298     case WLAN_CMD_GET_LISTLEN:
 299                 cbListCount = 0;
 300                 pBSS = &(pMgmt->sBSSList[0]);
 301         for (ii = 0; ii < MAX_BSS_NUM; ii++) {
 302             pBSS = &(pMgmt->sBSSList[ii]);
 303             if (!pBSS->bActive)
 304                 continue;
 305             cbListCount++;
 306         };
 307         sList.uItem = cbListCount;
 308         if (copy_to_user(pReq->data, &sList, sizeof(SBSSIDList))) {
 309                         result = -EFAULT;
 310                         break;
 311                 };
 312         pReq->wResult = 0;
 313         break;
 314
 315     case WLAN_CMD_GET_LIST:
 316         if (copy_from_user(&sList, pReq->data, sizeof(SBSSIDList))) {
 317                         result = -EFAULT;
 318                         break;
 319                 };
 320         pList = (PSBSSIDList)kmalloc(sizeof(SBSSIDList) + (sList.uItem * sizeof(SBSSIDItem)), (int)GFP_ATOMIC);
 321         if (pList == NULL) {
 322             result = -ENOMEM;
 323             break;
 324         }
 325                 pList->uItem = sList.uItem;
 326                 pBSS = &(pMgmt->sBSSList[0]);
 327         for (ii = 0, jj = 0; jj < MAX_BSS_NUM ; jj++) {
 328             pBSS = &(pMgmt->sBSSList[jj]);
 329             if (pBSS->bActive) {
 330                     pList->sBSSIDList[ii].uChannel = pBSS->uChannel;
 331                     pList->sBSSIDList[ii].wBeaconInterval = pBSS->wBeaconInterval;
 332                     pList->sBSSIDList[ii].wCapInfo = pBSS->wCapInfo;
 333                     RFvRSSITodBm(pDevice, (BYTE)(pBSS->uRSSI), &ldBm);
 334                     pList->sBSSIDList[ii].uRSSI = (UINT)ldBm;
 335 //                  pList->sBSSIDList[ii].uRSSI = pBSS->uRSSI;
 336                     memcpy(pList->sBSSIDList[ii].abyBSSID, pBSS->abyBSSID, WLAN_BSSID_LEN);
 337                     pItemSSID = (PWLAN_IE_SSID)pBSS->abySSID;
 338                     memset(pList->sBSSIDList[ii].abySSID, 0, WLAN_SSID_MAXLEN + 1);
 339                     memcpy(pList->sBSSIDList[ii].abySSID, pItemSSID->abySSID, pItemSSID->len);
 340                 if (WLAN_GET_CAP_INFO_ESS(pBSS->wCapInfo)) {
 341                         pList->sBSSIDList[ii].byNetType = INFRA;
 342                 }
 343                 else {
 344                         pList->sBSSIDList[ii].byNetType = ADHOC;
 345                     }
 346                     if (WLAN_GET_CAP_INFO_PRIVACY(pBSS->wCapInfo)) {
 347                         pList->sBSSIDList[ii].bWEPOn = TRUE;
 348                 }
 349                 else {
 350                         pList->sBSSIDList[ii].bWEPOn = FALSE;
 351                     }
 352                     ii ++;
 353                     if (ii >= pList->uItem)
 354                         break;
 355             }
 356         }
 357
 358         if (copy_to_user(pReq->data, pList, sizeof(SBSSIDList) + (sList.uItem * sizeof(SBSSIDItem)))) {
 359                         result = -EFAULT;
 360                         break;
 361                 };
 362         kfree(pList);
 363         pReq->wResult = 0;
 364         break;
 365
 366     case WLAN_CMD_GET_MIB:
 367         if (copy_to_user(pReq->data, &(pDevice->s802_11Counter), sizeof(SDot11MIBCount))) {
 368                         result = -EFAULT;
 369                         break;
 370                 };
 371         break;
 372
 373     case WLAN_CMD_GET_STAT:
 374         if (copy_to_user(pReq->data, &(pDevice->scStatistic), sizeof(SStatCounter))) {
 375                         result = -EFAULT;
 376                         break;
 377                 };
 378         break;
 379     case WLAN_CMD_STOP_MAC:
 380
 381         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_STOP_MAC\n");
 382         // Todo xxxxxx
 383         netif_stop_queue(pDevice->dev);
 384         spin_lock_irq(&pDevice->lock);
 385         if (pDevice->bRadioOff == FALSE) {
 386             CARDbRadioPowerOff(pDevice);
 387         }
 388         pDevice->bLinkPass = FALSE;
 389         ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 390         memset(pMgmt->abyCurrBSSID, 0, 6);
 391         pMgmt->eCurrState = WMAC_STATE_IDLE;
 392 //        del_timer(&pDevice->sTimerCommand);
 393 //        del_timer(&pMgmt->sTimerSecondCallback);
 394         pDevice->bCmdRunning = FALSE;
 395         spin_unlock_irq(&pDevice->lock);
 396
 397         break;
 398
 399     case WLAN_CMD_START_MAC:
 400
 401         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_START_MAC\n");
 402         // Todo xxxxxxx
 403         if (pDevice->bRadioOff == TRUE)
 404             CARDbRadioPowerOn(pDevice);
 405         break;
 406
 407     case WLAN_CMD_SET_HOSTAPD:
 408
 409         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_HOSTAPD\n");
 410
 411         if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
 412                         result = -EFAULT;
 413                         break;
 414                 };
 415                 if (sValue.dwValue == 1) {
 416             if (hostap_set_hostapd(pDevice, 1, 1) == 0){
 417                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable HOSTAP\n");
 418             }
 419             else {
 420                             result = -EFAULT;
 421                             break;
 422                         }
 423         }
 424         else {
 425             hostap_set_hostapd(pDevice, 0, 1);
 426             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable HOSTAP\n");
 427         }
 428
 429         break;
 430
 431     case WLAN_CMD_SET_HOSTAPD_STA:
 432
 433         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_HOSTAPD_STA\n");
 434
 435         break;
 436     case WLAN_CMD_SET_802_1X:
 437
 438         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_802_1X\n");
 439         if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
 440                         result = -EFAULT;
 441                         break;
 442                 };
 443
 444                 if (sValue.dwValue == 1) {
 445             pDevice->bEnable8021x = TRUE;
 446             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable 802.1x\n");
 447         }
 448         else {
 449             pDevice->bEnable8021x = FALSE;
 450             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable 802.1x\n");
 451         }
 452
 453         break;
 454
 455
 456     case WLAN_CMD_SET_HOST_WEP:
 457
 458         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_HOST_WEP\n");
 459         if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
 460                         result = -EFAULT;
 461                         break;
 462                 };
 463
 464                 if (sValue.dwValue == 1) {
 465             pDevice->bEnableHostWEP = TRUE;
 466             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable HostWEP\n");
 467         }
 468         else {
 469             pDevice->bEnableHostWEP = FALSE;
 470             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable HostWEP\n");
 471         }
 472
 473         break;
 474
 475     case WLAN_CMD_SET_WPA:
 476          DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_WPA\n");
 477
 478         if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
 479                         result = -EFAULT;
 480                         break;
 481                 };
 482                 if (sValue.dwValue == 1) {
 483                      DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "up wpadev\n");
 484                    memcpy(pDevice->wpadev->dev_addr, pDevice->dev->dev_addr, U_ETHER_ADDR_LEN);
 485                    pDevice->bWPADEVUp = TRUE;
 486         }
 487         else {
 488             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "close wpadev\n");
 489            pDevice->bWPADEVUp = FALSE;
 490         }
 491
 492         break;
 493
 494     case WLAN_CMD_AP_START:
 495
 496         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_AP_START\n");
 497         if (pDevice->bRadioOff == TRUE) {
 498             CARDbRadioPowerOn(pDevice);
 499             add_timer(&pMgmt->sTimerSecondCallback);
 500         }
 501         if (copy_from_user(&sStartAPCmd, pReq->data, sizeof(SCmdStartAP))) {
 502                         result = -EFAULT;
 503                         break;
 504                 };
 505
 506             if (sStartAPCmd.wBSSType == AP) {
 507                 pMgmt->eConfigMode = WMAC_CONFIG_AP;
 508                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct set to AP mode\n");
 509             }
 510             else {
 511                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct BSS type not set to AP mode\n");
 512                         result = -EFAULT;
 513                         break;
 514             }
 515
 516
 517             if (sStartAPCmd.wBBPType == PHY80211g) {
 518             pMgmt->byAPBBType = PHY_TYPE_11G;
 519         }
 520         else if (sStartAPCmd.wBBPType == PHY80211a) {
 521                  pMgmt->byAPBBType = PHY_TYPE_11A;
 522         }
 523         else {
 524             pMgmt->byAPBBType = PHY_TYPE_11B;
 525         }
 526
 527         pItemSSID = (PWLAN_IE_SSID)sStartAPCmd.ssid;
 528         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
 529                 memcpy(pMgmt->abyDesireSSID, pItemSSID, pItemSSID->len + WLAN_IEHDR_LEN);
 530
 531             if ((sStartAPCmd.uChannel > 0)&&(sStartAPCmd.uChannel <= 14))
 532                 pDevice->uChannel = sStartAPCmd.uChannel;
 533
 534             if ((sStartAPCmd.uBeaconInt >= 20) && (sStartAPCmd.uBeaconInt <= 1000))
 535             pMgmt->wIBSSBeaconPeriod = sStartAPCmd.uBeaconInt;
 536         else
 537             pMgmt->wIBSSBeaconPeriod = 100;
 538
 539         if (sStartAPCmd.bShareKeyAuth == TRUE){
 540             pMgmt->bShareKeyAlgorithm = TRUE;
 541             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Share Key \n");
 542         }
 543         else {
 544             pMgmt->bShareKeyAlgorithm = FALSE;
 545             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Open System \n");
 546         }
 547         memcpy(pMgmt->abyIBSSSuppRates, abySuppRates, 6);
 548
 549         if (sStartAPCmd.byBasicRate & BIT3) {
 550             pMgmt->abyIBSSSuppRates[2] |= BIT7;
 551             pMgmt->abyIBSSSuppRates[3] |= BIT7;
 552             pMgmt->abyIBSSSuppRates[4] |= BIT7;
 553             pMgmt->abyIBSSSuppRates[5] |= BIT7;
 554         }else if (sStartAPCmd.byBasicRate & BIT2) {
 555              pMgmt->abyIBSSSuppRates[2] |= BIT7;
 556              pMgmt->abyIBSSSuppRates[3] |= BIT7;
 557              pMgmt->abyIBSSSuppRates[4] |= BIT7;
 558         }else if (sStartAPCmd.byBasicRate & BIT1) {
 559              pMgmt->abyIBSSSuppRates[2] |= BIT7;
 560              pMgmt->abyIBSSSuppRates[3] |= BIT7;
 561         }else if (sStartAPCmd.byBasicRate & BIT1) {
 562              pMgmt->abyIBSSSuppRates[2] |= BIT7;
 563         }else {
 564             //default 1,2M
 565              pMgmt->abyIBSSSuppRates[2] |= BIT7;
 566              pMgmt->abyIBSSSuppRates[3] |= BIT7;
 567         }
 568
 569         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Support Rate= %x %x %x %x\n",
 570                 pMgmt->abyIBSSSuppRates[2],
 571                 pMgmt->abyIBSSSuppRates[3],
 572                 pMgmt->abyIBSSSuppRates[4],
 573                 pMgmt->abyIBSSSuppRates[5]
 574                 );
 575
 576         netif_stop_queue(pDevice->dev);
 577         spin_lock_irq(&pDevice->lock);
 578         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
 579         spin_unlock_irq(&pDevice->lock);
 580         break;
 581
 582     case WLAN_CMD_GET_NODE_CNT:
 583
 584                 cbListCount = 0;
 585                 pNode = &(pMgmt->sNodeDBTable[0]);
 586         for (ii = 0; ii < (MAX_NODE_NUM + 1); ii++) {
 587             pNode = &(pMgmt->sNodeDBTable[ii]);
 588             if (!pNode->bActive)
 589                 continue;
 590             cbListCount++;
 591         };
 592
 593         sNodeList.uItem = cbListCount;
 594         if (copy_to_user(pReq->data, &sNodeList, sizeof(SNodeList))) {
 595                         result = -EFAULT;
 596                         break;
 597                 };
 598         pReq->wResult = 0;
 599         break;
 600
 601     case WLAN_CMD_GET_NODE_LIST:
 602
 603         if (copy_from_user(&sNodeList, pReq->data, sizeof(SNodeList))) {
 604                         result = -EFAULT;
 605                         break;
 606                 };
 607         pNodeList = (PSNodeList)kmalloc(sizeof(SNodeList) + (sNodeList.uItem * sizeof(SNodeItem)), (int)GFP_ATOMIC);
 608         if (pNodeList == NULL) {
 609             result = -ENOMEM;
 610             break;
 611         }
 612                 pNodeList->uItem = sNodeList.uItem;
 613                 pNode = &(pMgmt->sNodeDBTable[0]);
 614         for (ii = 0, jj = 0; ii < (MAX_NODE_NUM + 1); ii++) {
 615             pNode = &(pMgmt->sNodeDBTable[ii]);
 616             if (pNode->bActive) {
 617                     pNodeList->sNodeList[jj].wAID = pNode->wAID;
 618                     memcpy(pNodeList->sNodeList[jj].abyMACAddr, pNode->abyMACAddr, WLAN_ADDR_LEN);
 619                     pNodeList->sNodeList[jj].wTxDataRate = pNode->wTxDataRate;
 620                     pNodeList->sNodeList[jj].wInActiveCount = (WORD)pNode->uInActiveCount;
 621                     pNodeList->sNodeList[jj].wEnQueueCnt = (WORD)pNode->wEnQueueCnt;
 622                     pNodeList->sNodeList[jj].wFlags = (WORD)pNode->dwFlags;
 623                     pNodeList->sNodeList[jj].bPWBitOn = pNode->bPSEnable;
 624                     pNodeList->sNodeList[jj].byKeyIndex = pNode->byKeyIndex;
 625                     pNodeList->sNodeList[jj].wWepKeyLength = pNode->uWepKeyLength;
 626                     memcpy(&(pNodeList->sNodeList[jj].abyWepKey[0]), &(pNode->abyWepKey[0]), WEP_KEYMAXLEN);
 627                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "key= %2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
 628                             pNodeList->sNodeList[jj].abyWepKey[0],
 629                             pNodeList->sNodeList[jj].abyWepKey[1],
 630                             pNodeList->sNodeList[jj].abyWepKey[2],
 631                             pNodeList->sNodeList[jj].abyWepKey[3],
 632                             pNodeList->sNodeList[jj].abyWepKey[4]
 633                            );
 634                     pNodeList->sNodeList[jj].bIsInFallback = pNode->bIsInFallback;
 635                     pNodeList->sNodeList[jj].uTxFailures = pNode->uTxFailures;
 636                     pNodeList->sNodeList[jj].uTxAttempts = pNode->uTxAttempts;
 637                     pNodeList->sNodeList[jj].wFailureRatio = (WORD)pNode->uFailureRatio;
 638                     jj ++;
 639                     if (jj >= pNodeList->uItem)
 640                         break;
 641                 }
 642                 };
 643         if (copy_to_user(pReq->data, pNodeList, sizeof(SNodeList) + (sNodeList.uItem * sizeof(SNodeItem)))) {
 644                         result = -EFAULT;
 645                         break;
 646                 };
 647         kfree(pNodeList);
 648         pReq->wResult = 0;
 649         break;
 650
 651 #ifdef WPA_SM_Transtatus
 652     case 0xFF:
 653         memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
 654             wpa_Result.proto = 0;
 655             wpa_Result.key_mgmt = 0;
 656             wpa_Result.eap_type = 0;
 657             wpa_Result.authenticated = FALSE;
 658               pDevice->fWPA_Authened = FALSE;
 659         if (copy_from_user(&wpa_Result, pReq->data, sizeof(wpa_Result))) {
 660             result = -EFAULT;
 661                         break;
 662                 }
 663 //DavidWang  for some AP maybe good authenticate
 664    if(wpa_Result.key_mgmt==0x20)
 665       pMgmt->Cisco_cckm =1;
 666     else
 667     pMgmt->Cisco_cckm =0;
 668 //DavidWang
 669
 670 if(wpa_Result.authenticated==TRUE) {
 671    #ifdef SndEvt_ToAPI
 672    {
 673      union iwreq_data      wrqu;
 674
 675      pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
 676
 677      memset(&wrqu, 0, sizeof(wrqu));
 678      wrqu.data.flags = RT_WPACONNECTED_EVENT_FLAG;
 679      wrqu.data.length =pItemSSID->len;
 680      wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, pItemSSID->abySSID);
 681    }
 682    #endif
 683          pDevice->fWPA_Authened = TRUE;           //is sucessful peer to wpa_Result.authenticated?
 684 }
 685
 686         //printk("get private wpa_supplicant announce WPA SM\n");
 687         //printk("wpa-->ifname=%s\n",wpa_Result.ifname);
 688         //printk("wpa-->proto=%d\n",wpa_Result.proto);
 689         //printk("wpa-->key-mgmt=%d\n",wpa_Result.key_mgmt);
 690         //printk("wpa-->eap_type=%d\n",wpa_Result.eap_type);
 691         //printk("wpa-->authenticated is %s\n",(wpa_Result.authenticated==TRUE)?"TRUE":"FALSE");
 692
 693         pReq->wResult = 0;
 694         break;
 695 #endif
 696
 697     default:
 698         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Private command not support..\n");
 699     }
 700
 701     return result;
 702 }