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