drivers/usb/net/Zydas/zdasocsvc.c

   1 #ifndef __ZDASOCSVC_C__
   2 #define __ZDASOCSVC_C__
   3
   4 #include "zd80211.h"
   5 #include "zd1205.h"
   6 #include "zdturbo_burst.h"
   7
   8 U8 AsocState = STE_ASOC_IDLE;
   9 static MacAddr_t AsSta;
  10 extern struct net_device *g_dev;
  11
  12
  13 BOOLEAN Disasoc(Signal_t *signal)
  14 {
  15         FrmDesc_t *pfrmDesc;
  16         Frame_t *rdu;
  17         MacAddr_t Sta;
  18         ReasonCode Rsn;
  19         U8 vapId = 0;
  20
  21         //ZDEBUG("Disasoc");
  22         //FPRINT("Disasoc");
  23         pfrmDesc = signal->frmInfo.frmDesc;
  24         rdu = pfrmDesc->mpdu;
  25         memcpy((U8 *)&Sta, (U8 *)(addr2(rdu)), 6); // Get the address of the transmitter.
  26         Rsn = (ReasonCode)(reason(rdu));
  27
  28         if (mBssType == INFRASTRUCTURE_BSS)
  29         {// This frame should be come from the associated AP.
  30             if ((!mAssoc) || (memcmp(&Sta, (U8*)&mBssId, 6) != 0))
  31             { //Not for this BSSID
  32                 //discard this packet
  33                 freeFdesc(pfrmDesc);
  34                 return TRUE;
  35             }
  36             else
  37             {
  38                 freeFdesc(pfrmDesc);
  39                 UpdateStaStatus(&Sta, STATION_STATE_DIS_ASOC, vapId);
  40                 pdot11Obj->StatusNotify(STA_DISASSOCIATED, (U8 *)&Sta);
  41                 mAssoc = FALSE;
  42                 memset((U8 *)&mBssId, 0, 6);
  43                 printk(KERN_ERR "Rx Disasoc from AP(Rsn:%d),set DIS_CONNECT_SET\n",Rsn);
  44                 mRequestFlag |= DIS_CONNECT_SET;
  45                 return TRUE;
  46             }
  47         }
  48         else if (mBssType == AP_BSS)
  49         {
  50             if (memcmp(addr1(rdu), (U8*)&mBssId, 6))
  51             { //Not for this BSSID
  52                 freeFdesc(pfrmDesc);
  53                 return TRUE;
  54             }
  55             UpdateStaStatus(&Sta, STATION_STATE_DIS_ASOC, vapId);
  56             freeFdesc(pfrmDesc);
  57             //here to handle disassoc ind.
  58             pdot11Obj->StatusNotify(STA_DISASSOCIATED, (U8 *)&Sta);
  59             return TRUE;
  60         }
  61         else
  62         {
  63             freeFdesc(pfrmDesc);
  64             return TRUE;
  65         }
  66 }
  67
  68
  69 BOOLEAN DisasocReq(Signal_t *signal)
  70 {
  71         FrmDesc_t *pfrmDesc;
  72         MacAddr_t Sta;
  73         ReasonCode Rsn = RC_UNSPEC_REASON;
  74         U8 vapId = 0;
  75
  76         //ZDEBUG("DisasocReq");
  77         //FPRINT("DisasocReq");
  78
  79         memcpy((U8 *)&Sta, (U8 *)&signal->frmInfo.Sta, 6);
  80         Rsn = signal->frmInfo.rCode;
  81         pdot11Obj->StatusNotify(STA_DISASSOCIATED, (U8 *)&Sta);
  82
  83         vapId = signal->vapId;
  84         UpdateStaStatus(&Sta, STATION_STATE_DIS_ASOC, vapId);
  85
  86         pfrmDesc = allocFdesc();
  87         if(!pfrmDesc){
  88                 sigEnque(pMgtQ, (signal));
  89                 return FALSE;
  90         }
  91
  92         mkDisAssoc_DeAuthFrm(pfrmDesc, ST_DISASOC, &Sta, Rsn, vapId);
  93         sendMgtFrame(signal, pfrmDesc);
  94
  95         if (mBssType == INFRASTRUCTURE_BSS){
  96                 if (memcmp((U8 *)&mBssId, (U8 *)&Sta, 6) == 0){ // my AP
  97                         mAssoc = FALSE;
  98                         memset((U8 *)&mBssId, 0, 6);
  99                 }
 100         }
 101
 102         return FALSE;
 103 }
 104
 105
 106 BOOLEAN Re_Asociate(Signal_t *signal)
 107 {
 108         struct zd1205_private *macp=g_dev->priv;
 109         Hash_t  *pHash;
 110         FrmDesc_t *pfrmDesc;
 111         Frame_t *rdu;
 112         MacAddr_t Sta;
 113         U16 aid = 0;
 114         StatusCode asStatus;
 115         U8 lsInterval;
 116         Element WPA;
 117         Element asSsid;
 118         Element asRates;
 119         Element extRates;
 120         U16 cap;
 121         U8 ZydasMode = 0;
 122         int i;
 123         U8 tmpMaxRate = 0x02;
 124         U8 MaxRate;
 125         U16 notifyStatus = STA_ASOC_REQ;
 126         U16 notifyStatus1 = STA_ASSOCIATED;
 127         TypeSubtype type = ST_ASOC_RSP;
 128         U8      Preamble = 0;
 129         U8      HigestBasicRate = 0;
 130         U8      vapId = 0;
 131         U8      Len;
 132         Element *pExtRate = NULL;
 133
 134         BOOLEAN bErpSta = TRUE;
 135         pExtRate = &mExtRates;
 136
 137         ZDEBUG("Re_Asociate");
 138         pfrmDesc = signal->frmInfo.frmDesc;
 139
 140         if (mBssType == INFRASTRUCTURE_BSS){
 141                 freeFdesc(pfrmDesc);
 142                 return TRUE;
 143         } else if (mBssType == AP_BSS){
 144                 rdu = pfrmDesc->mpdu;
 145                 lsInterval = listenInt(pfrmDesc->mpdu);
 146                 //FPRINT_V("lsInterval", lsInterval);
 147                 cap = cap(rdu);
 148                 memcpy((U8 *)&Sta, (U8 *)addr2(rdu), 6);
 149
 150                 if ((isGroup(addr2(rdu))) ||  (!getElem(rdu, EID_SSID, &asSsid,1))
 151                         || (!getElem(rdu, EID_SUPRATES, &asRates,1))){
 152                         freeFdesc(pfrmDesc);
 153                         return TRUE;
 154                 }
 155
 156                 if ((eLen(&asSsid) != eLen(&dot11DesiredSsid) ||
 157                         memcmp(&asSsid, &dot11DesiredSsid, eLen(&dot11DesiredSsid)+2) != 0)){
 158                         freeFdesc(pfrmDesc);
 159                         return TRUE;
 160                 }
 161
 162                 //check capability
 163                 if (cap & CAP_SHORT_PREAMBLE){
 164                         if (mPreambleType == LONG_PREAMBLE){ //we are long preamble, and STA is short preamble capability
 165                                 freeFdesc(pfrmDesc);
 166                                 return TRUE;
 167                         }
 168                         else
 169                                 Preamble = 1;
 170                 }
 171                 else {
 172                         Preamble = 0;
 173                 }
 174
 175
 176                 // Privacy not match
 177                 if (cap & CAP_PRIVACY){
 178                         if (!mPrivacyInvoked && macp->cardSetting.WPAIeLen==0){
 179                         //if (!mPrivacyInvoked){
 180                                 freeFdesc(pfrmDesc);
 181                                 return TRUE;
 182                         }
 183                 }
 184                 else {
 185                         if (mPrivacyInvoked){
 186                                 freeFdesc(pfrmDesc);
 187                                 return TRUE;
 188                         }
 189                 }
 190
 191                 //check short slot time
 192 #if 0//defined(OFDM)
 193                 if (mMacMode != PURE_B_MODE){
 194                         if (cap & CAP_SHORT_SLOT_TIME){
 195                                 if (!(mCap & CAP_SHORT_SLOT_TIME)){
 196                                         FPRINT("CAP_SHORT_SLOT_TIME not match!!");
 197                                         freeFdesc(pfrmDesc);
 198                                         return TRUE;
 199                                 }
 200                         }
 201                         else {
 202                                 if (mCap & CAP_SHORT_SLOT_TIME){
 203                                         asStatus = (StatusCode)SC_UNSUP_SHORT_SLOT_TIME;
 204                                         goto check_failed;
 205                                 }
 206                         }
 207                 }
 208
 209                 FPRINT_V("cap", cap);
 210 #endif
 211
 212
 213                 //check supported rates
 214                 Len = eLen(&asRates);
 215                 for (i=0; i<Len; i++){
 216                         if ( (asRates.buf[2+i] & 0x7f) > tmpMaxRate ){
 217                                 tmpMaxRate = (asRates.buf[2+i] & 0x7f);
 218                                 if (asRates.buf[2+i] & 0x80)
 219                                         HigestBasicRate = asRates.buf[2+i];
 220                         }
 221
 222                         if (((asRates.buf[2+i] & 0x7f) == 0x21) && (!(cap & CAP_PBCC_ENABLE))){ //Zydas 16.5M
 223                                 ZydasMode = 1;
 224                                 mZyDasModeClient = TRUE;
 225                         //FPRINT("ZydasMode");
 226                         }
 227                 }
 228
 229                 if (!getElem(rdu, EID_EXT_RATES, &extRates,1)){
 230                         void *reg = pdot11Obj->reg;
 231                         // 11b STA
 232                         //FPRINT("11b STA");
 233                         if (mMacMode == PURE_G_MODE){ // don't support b only sta
 234                                 MaxRate = RateConvert((tmpMaxRate & 0x7f));
 235                                 //MaxBasicRate = RateConvert((HigestBasicRate & 0x7f));
 236                                 if (MaxRate < pdot11Obj->BasicRate){
 237                                         //FPRINT_V("MaxRate", MaxRate);
 238                                         //FPRINT_V("pdot11Obj->BasicRate", pdot11Obj->BasicRate);
 239                                         asStatus = SC_UNSUP_RATES;
 240                                         goto check_failed;
 241                                 }
 242                         }
 243                         bErpSta = FALSE;
 244             pdot11Obj->ConfigFlag |= NON_ERP_PRESENT_SET;
 245             pdot11Obj->ConfigFlag &= ~SHORT_SLOT_TIME_SET;
 246                         mCap &= ~CAP_SHORT_SLOT_TIME;
 247                         pdot11Obj->SetReg(reg, ZD_CWmin_CWmax, CW_NORMAL_SLOT);
 248                         if(PURE_A_MODE == mMacMode) {
 249                                 pdot11Obj->ConfigFlag &= ~NON_ERP_PRESENT_SET;
 250                                 pdot11Obj->ConfigFlag |= SHORT_SLOT_TIME_SET;
 251                                 mCap |= CAP_SHORT_SLOT_TIME;
 252                                 pdot11Obj->SetReg(reg, ZD_CWmin_CWmax, CW_SHORT_SLOT);
 253                         }
 254
 255                 }
 256                 else { //11g STA
 257                         if (mMacMode != PURE_B_MODE && mMacMode != PURE_A_MODE){
 258
 259                                 Len = eLen(&extRates);
 260                                 for (i=0; i<Len; i++){
 261                                         if ( (extRates.buf[2+i] & 0x7f) > tmpMaxRate ){
 262                                                 tmpMaxRate = (extRates.buf[2+i] & 0x7f);
 263                                         }
 264                                 }
 265                                 bErpSta = TRUE;
 266                                 //FPRINT("11g STA");
 267                         }
 268                         else {
 269                                 FPRINT("Pure B mode don't support G sta");
 270                                 asStatus = SC_UNSUP_RATES;
 271                                 goto check_failed;
 272                         }
 273                 }
 274
 275                 MaxRate = RateConvert((tmpMaxRate & 0x7f));
 276
 277         if (MaxRate > mMaxTxRate)
 278             MaxRate = mMaxTxRate;
 279
 280                 if (signal->id == SIG_REASSOC)
 281                         notifyStatus = STA_REASOC_REQ;
 282
 283                 if (!pdot11Obj->StatusNotify(notifyStatus, (U8 *)&Sta))
 284                 { //Accept it
 285                         //if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES)){
 286                         if (macp->cardSetting.WPAIeLen)
 287             {
 288                                 if (getElem(rdu, EID_WPA, &WPA,1)||getElem(rdu,EID_RSN,&WPA,1))
 289                                 {
 290                                         //zd1205_OctetDump("AssocRequest = ", asRdu->body, asRdu->bodyLen);
 291                                         //zd1205_OctetDump("AssocRequest WPA_IE = ", &WPA.buf[2], WPA.buf[1]);
 292                                         if (pdot11Obj->AssocRequest)
 293                                         {
 294                                                 if (pdot11Obj->AssocRequest((U8 *)&Sta, rdu->body, rdu->bodyLen))
 295                                                 { //reject
 296                                                         asStatus = SC_UNSPEC_FAILURE;
 297                                                         goto check_failed;
 298                                                         //we need reason code here
 299                                                 }
 300                                         }
 301                                 }
 302                                 else
 303                                 {
 304                                     asStatus = SC_UNSPEC_FAILURE;
 305                                     goto wpa_check_failed;
 306                                 }
 307                         }
 308
 309 //wpa_check_ok:
 310                         if (!UpdateStaStatus(&Sta, STATION_STATE_ASOC, vapId)){
 311                                 asStatus = SC_AP_FULL;
 312                         }
 313                         else{
 314                                 AssocInfoUpdate(&Sta, MaxRate, lsInterval, ZydasMode, Preamble, bErpSta, 0,0,1,vapId);
 315                                 aid = AIdLookup(&Sta);
 316                                 printk(KERN_DEBUG "Re_Asoc: aid=%d\n", aid);
 317                                 pHash = HashSearch(&Sta);
 318                                 if (pHash != NULL)
 319                                 {
 320                                         if (!pHash->AlreadyIn)
 321                                         {
 322                                                 pHash->AlreadyIn=1;
 323                                                 mCurrConnUser++;
 324                                                 if (bErpSta == FALSE)
 325                                                 {
 326                                                         printk(KERN_DEBUG "Increment mNumBOnlySta\n");
 327                                                         mNumBOnlySta++;
 328                                                 }
 329                                         }
 330                                 }
 331
 332                                 asStatus = SC_SUCCESSFUL;
 333                                 if (signal->id == SIG_REASSOC)
 334                                         notifyStatus1 = STA_REASSOCIATED;
 335                                 pdot11Obj->StatusNotify(notifyStatus1, (U8 *)&Sta);
 336
 337                                 if (mMacMode != PURE_B_MODE && mMacMode != PURE_A_MODE){
 338                                         if (pdot11Obj->ConfigFlag & NON_ERP_PRESENT_SET){
 339                                                 U32 tmpValue;
 340                                                 void *reg = pdot11Obj->reg;
 341
 342                                                 // force enabled protection mode for debug
 343                                                 mErp.buf[2] |= (NON_ERP_PRESENT | USE_PROTECTION);
 344                                                 tmpValue = pdot11Obj->GetReg(reg, ZD_RTS_CTS_Rate);
 345                                                 tmpValue &= ~CTS_MOD_TYPE_OFDM;
 346                                                 tmpValue |= CTS_RATE_11M;
 347                                                 pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, tmpValue);
 348
 349                                                 if (Preamble == 0){ //long preamble
 350                                                         mErp.buf[2] |= BARKER_PREAMBLE;
 351                                                         tmpValue = pdot11Obj->GetReg(reg, ZD_RTS_CTS_Rate);
 352                                                         tmpValue &= ~NON_BARKER_PMB_SET;
 353                                                         tmpValue |= CTS_RATE_11M;
 354                                                         pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, tmpValue);
 355                                                         //FPRINT("Enable Barker Preamble");
 356                                                 }
 357                                                 pdot11Obj->ConfigFlag |= ENABLE_PROTECTION_SET;
 358                                                 //FPRINT("Enable Protection Mode");
 359                                         }
 360                                 }
 361
 362                         }
 363                 }
 364                 else{
 365 //wpa_check_failed:
 366                         asStatus = SC_UNSPEC_FAILURE;
 367                 }
 368 wpa_check_failed:
 369
 370                 aid |= 0xC000;
 371                 if (aid != 0xC000){
 372                         FPRINT_V("Aid", aid);
 373                         FPRINT_V("MaxRate", MaxRate);
 374                 }
 375
 376 check_failed:
 377                 if (signal->id == SIG_REASSOC)
 378                         type = ST_REASOC_RSP;
 379                 mkRe_AsocRspFrm(pfrmDesc, type, &Sta, mCap, asStatus, aid, &mBrates, pExtRate, vapId);
 380                 sendMgtFrame(signal, pfrmDesc);
 381
 382                 return FALSE;
 383         }
 384         else {
 385                 freeFdesc(pfrmDesc);
 386                 return TRUE;
 387         }
 388 }
 389
 390 BOOLEAN Re_AsocReq(Signal_t *signal)
 391 {
 392         FrmDesc_t *pfrmDesc;
 393         U8 vapId = 0;
 394         TypeSubtype subType = ST_ASOC_REQ;
 395         Element *pExtRate = NULL;
 396
 397         FPRINT("Re_AsocReq");
 398
 399         pfrmDesc = allocFdesc();
 400         if(!pfrmDesc){
 401                 sigEnque(pMgtQ, (signal));
 402                 return FALSE;
 403         }
 404
 405
 406         if (signal->id == SIG_REASSOC_REQ){
 407                 subType = ST_REASOC_REQ;
 408         }
 409
 410         pExtRate = &mExtRates;
 411
 412         memcpy((U8 *)&AsSta, (U8 *)&mBssId, 6);
 413
 414         mkRe_AsocReqFrm(pfrmDesc, subType, &mBssId, mCap, mListenInterval,
 415                 &mOldAP, &mSsid, &mBrates, pExtRate, &mWPAIe, vapId);
 416
 417         pdot11Obj->StartTimer(ASOC_TIMEOUT, DO_ASOC);
 418         AsocState = STE_WAIT_ASOC_RSP;
 419         return sendMgtFrame(signal, pfrmDesc);
 420 }
 421
 422 BOOLEAN Re_AsocRsp(Signal_t *signal)
 423 {
 424     int i;
 425     BssInfo_t *asocBss = NULL;
 426     U8 Turbo_AMSDU = FALSE, Turbo_BURST = FALSE, Turbo_AMSDU_LEN = 1;
 427         Hash_t  *pHash;
 428         FrmDesc_t *pfrmDesc;
 429         Frame_t *rdu;
 430         U8 vapId = 0;
 431         MacAddr_t Sta;
 432         U16 status;
 433
 434         //ZDEBUG("Re_AsocRsp");
 435         FPRINT("Re_AsocRsp");
 436
 437         pfrmDesc = signal->frmInfo.frmDesc;
 438         rdu = pfrmDesc->mpdu;
 439
 440         memcpy((U8 *)&Sta, (U8 *)addr2(rdu), 6);
 441         if (memcmp(&AsSta, &Sta, 6) != 0){
 442                 //FPRINT("Not for my Assoc AP");
 443                 goto asoc_release;
 444         }
 445
 446         pdot11Obj->StopTimer(DO_ASOC);
 447         AsocState = STE_ASOC_IDLE;
 448
 449
 450         status = status(rdu);
 451         if (status == SC_SUCCESSFUL){
 452                 U8      Len;
 453                 U8      tmpMaxRate = 0x02;
 454                 U8      ZydasMode = 0;
 455                 U8      Preamble = 0;
 456                 U8      MaxRate;
 457                 BOOLEAN bErpSta = FALSE;
 458                 int i;
 459                 U8      HigestBasicRate = 0;
 460
 461                 UpdateStaStatus(&Sta, STATION_STATE_ASOC, vapId);
 462                 pHash = HashSearch(&Sta);
 463                 if (pHash != NULL)
 464                 {
 465                         if (!pHash->AlreadyIn)
 466                         {
 467                                 pHash->AlreadyIn=1;
 468                                 mCurrConnUser++;
 469                         }
 470                 }
 471
 472                 mAPCap = cap(rdu);
 473
 474                 //check capability
 475                 if (mAPCap & CAP_SHORT_PREAMBLE){
 476                         Preamble = 1;
 477                 }
 478                 else {
 479                         Preamble = 0;
 480                 }
 481
 482                 mAid = (aid(rdu) & 0x3FFF);
 483                 getElem(rdu, EID_SUPRATES, &mAPBrates,1);
 484                 //zd1205_dump_data("mAPBrates", &mAPBrates.buf[2], mAPBrates.buf[1]);
 485
 486                 if (getElem(rdu, EID_EXT_RATES, &mAPErates,1)){
 487                         //zd1205_dump_data("mAPErates", &mAPErates.buf[2], mAPErates.buf[1]);
 488                 }
 489
 490                 memcpy((U8 *)&mBssId, (U8 *)addr2(rdu), 6);
 491                 mAssoc = TRUE;
 492
 493                 //update supported rates
 494                 HW_SetSupportedRate(pdot11Obj, (U8 *)&mAPBrates);
 495                 HW_SetSupportedRate(pdot11Obj, (U8 *)&mAPErates);
 496
 497                 Len = eLen(&mAPBrates);
 498                 for (i=0; i<Len; i++){
 499                         if ((mAPBrates.buf[2+i] & 0x7f) > tmpMaxRate ){
 500                                 tmpMaxRate = (mAPBrates.buf[2+i] & 0x7f);
 501                                 if (mAPBrates.buf[2+i] & 0x80)
 502                                         HigestBasicRate = mAPBrates.buf[2+i];
 503                         }
 504
 505                         if (((mAPBrates.buf[2+i] & 0x7f) == 0x21) && (!(mAPCap & CAP_PBCC_ENABLE))){ //Zydas 16.5M
 506                                 ZydasMode = 1;
 507                         }
 508                 }
 509
 510
 511                 Len = eLen(&mAPErates);
 512                 for (i=0; i<Len; i++){
 513                         if ((mAPErates.buf[2+i] & 0x7f) > tmpMaxRate ){
 514                                 tmpMaxRate = (mAPErates.buf[2+i] & 0x7f);
 515                                 if (mAPErates.buf[2+i] & 0x80)
 516                                         HigestBasicRate = mAPErates.buf[2+i];
 517                         }
 518                 }
 519
 520                 //FPRINT_V("tmpMaxRate", tmpMaxRate);
 521                 //FPRINT_V("mMaxTxRate", mMaxTxRate);
 522                 MaxRate = RateConvert((tmpMaxRate & 0x7f));
 523                 //FPRINT_V("MaxRate", MaxRate);
 524                 if (MaxRate > mMaxTxRate)
 525                         MaxRate = mMaxTxRate;
 526                 memset(mAPBrates.buf, 0, sizeof(Element));
 527                 memset(mAPErates.buf, 0, sizeof(Element));
 528 #if ZDCONF_LP_SUPPORT == 1
 529         asocBss = zd1212_bssid_to_BssInfo(mBssId.mac);
 530         if(asocBss != NULL)
 531         {
 532             if(asocBss->zdIE_BURST.buf[0] == EID_ZYDAS)
 533             {
 534                 if(asocBss->zdIE_BURST.buf[8] & BIT_7)
 535                     Turbo_BURST = TRUE;
 536                 Turbo_BURST = Turbo_BURST && pdot11Obj->BURST_MODE;
 537             }
 538
 539             if(asocBss->zdIE_AMSDU.buf[0] == EID_ZYDAS)
 540             {
 541                 if(asocBss->zdIE_AMSDU.buf[8] & BIT_0)
 542                 {
 543                     Turbo_AMSDU = TRUE;
 544                     Turbo_AMSDU_LEN = asocBss->zdIE_AMSDU.buf[8] & BIT_1;
 545                 }
 546                 Turbo_AMSDU = Turbo_AMSDU && pdot11Obj->LP_MODE;
 547             }
 548         }
 549         else
 550         {
 551             printk("zd1212_bssid_to_BssInfo is NULL in %s, Something wrong\n", __FUNCTION__);
 552         }
 553
 554         AssocInfoUpdate(&mBssId, MaxRate, mAid, ZydasMode, Preamble, bErpSta, Turbo_BURST, Turbo_AMSDU, Turbo_AMSDU_LEN,vapId);
 555 #elif ZDCONF_LP_SUPPORT == 0
 556         AssocInfoUpdate(&mBssId, MaxRate, mAid, ZydasMode, Preamble, bErpSta,0,0,0,vapId);
 557 #endif
 558
 559                 pdot11Obj->StatusNotify(STA_ASSOCIATED, (U8 *)&mBssId);
 560                 pdot11Obj->Aid = mAid;
 561                 mConnRetryCnt = 0;
 562
 563                 FPRINT_V("Aid", mAid);
 564                 FPRINT_V("MaxRate", MaxRate);
 565         } else {
 566                 FPRINT("Asoc Failed!!!");
 567                 FPRINT_V("Status Code", status);
 568         }
 569
 570 asoc_release:
 571         freeFdesc(pfrmDesc);
 572         return TRUE;
 573 }
 574
 575
 576 BOOLEAN AsocTimeOut(Signal_t *signal)
 577 {
 578         U8 vapId = 0;
 579         FPRINT("AsocTimeOut");
 580
 581         if (AsocState == STE_WAIT_ASOC_RSP){
 582                 AsocState = STE_ASOC_IDLE;
 583                 UpdateStaStatus(&mBssId, STATION_STATE_DIS_ASOC, vapId);
 584         }
 585
 586         mRequestFlag |= CONNECT_TOUT_SET;
 587         return FALSE;
 588 }
 589
 590
 591 BOOLEAN AsocEntry(Signal_t *signal)
 592 {
 593         FrmDesc_t *pfrmDesc;
 594
 595         if (AsocState == STE_ASOC_IDLE){
 596                 switch(signal->id){
 597                         case SIG_DIASSOC_REQ:
 598                                 return DisasocReq(signal);
 599
 600                         case SIG_DISASSOC:
 601                                 return Disasoc(signal);
 602
 603                         case SIG_ASSOC:
 604                         case SIG_REASSOC:
 605                                 return Re_Asociate(signal);
 606
 607                         case SIG_ASSOC_REQ:
 608                         case SIG_REASSOC_REQ:
 609                 if(memcmp(mBssId.mac, zeroMacAddress, ETH_ALEN) == 0)
 610                    goto asoc_discard;
 611                                 return Re_AsocReq(signal);
 612
 613                         default:
 614                                 goto asoc_discard;
 615                 }
 616         } else if (AsocState == STE_WAIT_ASOC_RSP){
 617                 switch(signal->id){
 618                         case SIG_DIASSOC_REQ:
 619                                 return DisasocReq(signal);
 620
 621                         case SIG_DISASSOC:
 622                                 return Disasoc(signal);
 623
 624                         case SIG_ASSOC:
 625                         case SIG_REASSOC:
 626                                 return Re_Asociate(signal);
 627
 628                         case SIG_ASSOC_REQ:
 629                         case SIG_REASSOC_REQ:
 630                 if(memcmp(mBssId.mac, zeroMacAddress, ETH_ALEN) == 0)
 631                    goto asoc_discard;
 632                                 return Re_AsocReq(signal);
 633
 634                         case SIG_ASSOC_RSP:
 635                         case SIG_REASSOC_RSP:
 636                                 return Re_AsocRsp(signal);
 637
 638                         case SIG_TO_ASOC:
 639
 640                                 return AsocTimeOut(signal);
 641
 642                         default:
 643                                 goto asoc_discard;
 644                 }
 645         } else
 646                 goto asoc_discard;
 647
 648 asoc_discard:
 649         pfrmDesc = signal->frmInfo.frmDesc;
 650         freeFdesc(pfrmDesc);
 651         return TRUE;
 652 }
 653
 654 #endif
 655