drivers/usb/net/Zydas/zdsynch.c

   1 #ifndef __ZDSYNCH_C__
   2 #define __ZDSYNCH_C__
   3
   4 #include "zd80211.h"
   5 extern u8 LastMacMode;
   6 extern u8 mMacMode;
   7 //extern CurrScanCH;
   8 extern const U16 dot11A_Channel[];
   9 extern u8 LastSetChannel;
  10
  11 void zd_makeRateInfoMAP(U8 *pRates, U16 *basicRateMap, U16 *supRateMap)
  12 {
  13         int j;
  14         U8 rate;
  15         U8 eleLen = *(pRates+1);
  16
  17         for (j=0; j<eleLen; j++){
  18                 rate =  *(pRates+2+j);
  19                 switch (rate & 0x7f){
  20                         case SR_1M:
  21                                 *supRateMap |= BIT_0;
  22                                 if (rate & 0x80)
  23                                         *basicRateMap |= BIT_0;
  24                                 break;
  25
  26                         case SR_2M:
  27                                 *supRateMap |= BIT_1;
  28                                 if (rate & 0x80)
  29                                         *basicRateMap |= BIT_1;
  30                                 break;
  31
  32                         case SR_5_5M:
  33                                 *supRateMap |= BIT_2;
  34                                 if (rate & 0x80)
  35                                         *basicRateMap |= BIT_2;
  36                                 break;
  37
  38                         case SR_11M:
  39                                 *supRateMap |= BIT_3;
  40                                 if (rate & 0x80)
  41                                         *basicRateMap |= BIT_3;
  42                                 break;
  43
  44                         case SR_6M:
  45                                 *supRateMap |= BIT_4;
  46                                 if (rate & 0x80)
  47                                         *basicRateMap |= BIT_4;
  48                                 break;
  49
  50                         case SR_9M:
  51                                 *supRateMap |= BIT_5;
  52                                 if (rate & 0x80)
  53                                         *basicRateMap |= BIT_5;
  54                                 break;
  55
  56                         case SR_12M:
  57                                 *supRateMap |= BIT_6;
  58                                 if (rate & 0x80)
  59                                         *basicRateMap |= BIT_6;
  60                                 break;
  61
  62                         case SR_18M:
  63                                 *supRateMap |= BIT_7;
  64                                 if (rate & 0x80)
  65                                         *basicRateMap |= BIT_7;
  66                                 break;
  67
  68                         case SR_24M:
  69                                 *supRateMap |= BIT_8;
  70                                 if (rate & 0x80)
  71                                         *basicRateMap |= BIT_8;
  72                                 break;
  73
  74                         case SR_36M:
  75                                 *supRateMap |= BIT_9;
  76                                 if (rate & 0x80)
  77                                         *basicRateMap |= BIT_9;
  78                                 break;
  79
  80                         case SR_48M:
  81                                 *supRateMap |= BIT_10;
  82                                 if (rate & 0x80)
  83                                         *basicRateMap |= BIT_10;
  84                                 break;
  85
  86                         case SR_54M:
  87                                 *supRateMap |= BIT_11;
  88                                 if (rate & 0x80)
  89                                         *basicRateMap |= BIT_11;
  90                                 break;
  91
  92 #if 0
  93                         case SR_16_5M:
  94                                 *supRateMap |= BIT_12;
  95                                 if (rate & 0x80)
  96                                         *basicRateMap |= BIT_12;
  97                                 break;
  98
  99                         case SR_27_5M:
 100                                 *supRateMap |= BIT_13;
 101                                 if (rate & 0x80)
 102                                         *basicRateMap |= BIT_13;
 103                                 break;
 104 #endif
 105                         default:
 106
 107                                 break;
 108                 }
 109         }
 110 }
 111
 112 BOOLEAN Probe(Signal_t *signal)
 113 {
 114         FrmDesc_t *pfrmDesc;
 115         Frame_t *rdu;
 116         MacAddr_t sta;
 117         Element rSsid;
 118         Element *pWPA = NULL;
 119         U8 vapId = 0;
 120         Element *pExtRate = NULL;
 121
 122         ZDEBUG("Probe");
 123
 124
 125         pfrmDesc = signal->frmInfo.frmDesc;
 126         rdu = pfrmDesc->mpdu;
 127
 128         if (mBssType == INFRASTRUCTURE_BSS){
 129                 goto release;
 130         }
 131
 132         if (!getElem(rdu, EID_SSID, &rSsid,1))
 133                 goto release;
 134
 135         if (mHiddenSSID){ //discard broadcast ssid
 136                 if (eLen(&rSsid) == 0){
 137                         goto release;
 138                 }
 139         }
 140
 141         memcpy((U8*)&sta, (U8*)addr2(rdu), 6);
 142         pExtRate = &mExtRates;
 143
 144
 145
 146         if (eLen(&rSsid) == 0){
 147                 //WPA
 148                 if (mDynKeyMode == DYN_KEY_TKIP || mDynKeyMode==DYN_KEY_AES)
 149                         pWPA = &mWPAIe;
 150
 151
 152                 mkProbeRspFrm(pfrmDesc, &sta, mBeaconPeriod, mCap, &dot11DesiredSsid, &mBrates, &mPhpm, pExtRate, (Element *)pWPA, vapId);
 153                 return sendMgtFrame(signal, pfrmDesc);
 154         }
 155         else{
 156                 if (memcmp(&rSsid, &dot11DesiredSsid, eLen(&dot11DesiredSsid)+2) == 0){
 157                         //WPA
 158                     if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))
 159                                 pWPA = &mWPAIe;
 160
 161                         mkProbeRspFrm(pfrmDesc, &sta, mBeaconPeriod, mCap, &dot11DesiredSsid, &mBrates, &mPhpm, pExtRate, (Element *)pWPA, vapId);
 162                         return sendMgtFrame(signal, pfrmDesc);
 163                 }
 164         }
 165
 166 release:
 167         ZDEBUG("goto release");
 168         freeFdesc(pfrmDesc);
 169         return TRUE;
 170 }
 171
 172 BOOLEAN ProbeReq(Signal_t *signal)
 173 {
 174         FrmDesc_t *pfrmDesc;
 175         Element BCSsid;
 176         U8 vapId = 0;
 177         Element *pSsid = NULL;
 178         Element *pExtRate = NULL;
 179
 180         ZDEBUG("ProbeReq");
 181         //FPRINT("ProbeReq");
 182
 183         pfrmDesc = allocFdesc();
 184         if(!pfrmDesc){
 185                 sigEnque(pMgtQ, (signal));
 186                 return FALSE;
 187         }
 188
 189         BCSsid.buf[0] = EID_SSID;
 190         BCSsid.buf[1] = 0;
 191
 192
 193         if (mProbeWithSsid){
 194                 //pSsid = &mSsid;
 195                 pSsid = &dot11DesiredSsid;
 196         } else {
 197                 pSsid = &BCSsid;
 198         }
 199
 200         pExtRate = &mExtRates;
 201
 202         mkProbeReqFrm(pfrmDesc, &dot11BCAddress, pSsid, &mBrates, pExtRate, NULL, vapId);
 203         if (signal->vapId == 0)
 204             pdot11Obj->StartTimer(SCAN_TIMEOUT, DO_SCAN);
 205         //mProbeWithSsid = FALSE;
 206         return sendMgtFrame(signal, pfrmDesc);
 207 }
 208
 209 BOOLEAN ProbeRsp_Beacon(Signal_t *signal)
 210 {
 211         FrmDesc_t *pfrmDesc;
 212         Frame_t *rdu;
 213         MacAddr_t *pBssid = NULL;
 214         //Element *pWPA = NULL;
 215         U16 Cap = 0;
 216         U16 BcnInterval = 0;
 217         int i;
 218         U8 FrmType;
 219         BOOLEAN bUpdateInfo = FALSE;
 220         U8 index;
 221     U8 elemIdx=1;
 222 #if ZDCONF_LP_SUPPORT == 1
 223     Element tmpElement ;
 224 #endif
 225 #if ZDCONF_SES_SUPPORT == 1
 226     U8 SES_OUI[] = { 0x00, 0x90, 0x4C };
 227 #endif
 228     u8 WPA_OUI[4]={0x00, 0x50, 0xF2, 0x01};
 229     U16 loopCheck = 0;
 230     U8  *pAddr2ForIBSS;
 231
 232
 233
 234         BssInfo_t *pCurrBssInfo;
 235
 236         ZDEBUG("ProbeRsp_Beacon");
 237         pfrmDesc = signal->frmInfo.frmDesc;
 238         rdu = pfrmDesc->mpdu;
 239
 240         FrmType = frmType(rdu);
 241
 242         if (pdot11Obj->ConfigFlag & ACTIVE_CHANNEL_SCAN_SET){
 243                 Cap = cap1(rdu);
 244                 //FPRINT_V("Cap", Cap);
 245                 BcnInterval = beaconInt(rdu);
 246
 247         pAddr2ForIBSS =  (u8*) addr2(rdu);
 248                 if (Cap & CAP_IBSS){
 249                         pBssid = addr3(rdu);
 250                 }
 251                 else
 252                         pBssid = addr3(rdu);
 253
 254                 index = mBssNum;
 255                 //The following if-statements is used to filter existing AP Info.
 256                 //The rule is:
 257                 //1. The bssid is seen before.
 258                 //2. The old Info.apMode equals to LastMacMode
 259                 //The meaning is if the incoming ap's bssid == old's bssid and
 260                 // ap's apMode(judged by LastMacMode) == old's apMode then Drop It.
 261                 for (i=0; i<mBssNum; i++){
 262                         if ((memcmp((U8 *)&mBssInfo[i].bssid, (U8 *)pBssid, 6) == 0) &&
 263                                 ((PURE_A_AP==mBssInfo[i].apMode&& PURE_A_MODE==LastMacMode) ||
 264                  (PURE_A_AP!=mBssInfo[i].apMode&& PURE_A_MODE!=LastMacMode)
 265                                 )
 266                            ) {
 267                                 if (FrmType == ST_BEACON) {
 268                                         goto release;
 269                                 }
 270                                 else {
 271                                         bUpdateInfo = TRUE;
 272                                         index = i;
 273                                 }
 274                         }
 275                 }
 276
 277                 pCurrBssInfo =  &mBssInfo[index];
 278                 pCurrBssInfo->basicRateMap = 0;
 279                 pCurrBssInfo->supRateMap = 0;
 280
 281                 /* Reset supRates, extRates */
 282                 memset(&pCurrBssInfo->supRates, 0, NUM_SUPPORTED_RATE);
 283                 memset(&pCurrBssInfo->extRates, 0, NUM_SUPPORTED_RATE);
 284 #if ZDCONF_LP_SUPPORT == 1
 285         memset(&pCurrBssInfo->zdIE_BURST,0, sizeof(Element));
 286         memset(&pCurrBssInfo->zdIE_AMSDU,0, sizeof(Element));
 287         memset(&tmpElement,0, sizeof(Element));
 288 #endif
 289 #if ZDCONF_SES_SUPPORT == 1
 290         memset(&pCurrBssInfo->SES_Element,0, sizeof(Element));
 291         pCurrBssInfo->SES_Element_Valid = FALSE;
 292 #endif
 293
 294                 //get bssid
 295                 memcpy((U8 *)&pCurrBssInfo->bssid, (U8 *)pBssid, 6);
 296
 297                 //get beacon interval
 298                 pCurrBssInfo->bcnInterval = BcnInterval;
 299
 300                 //get capability
 301                 pCurrBssInfo->cap = Cap;
 302
 303                 if (!getElem(rdu, EID_SSID, &pCurrBssInfo->ssid,1)){
 304                         goto release;
 305                 }
 306
 307                 if (!getElem(rdu, EID_SUPRATES, &pCurrBssInfo->supRates,1)){
 308                         goto release;
 309                 }
 310
 311                 if (!getElem(rdu, EID_DSPARMS, &pCurrBssInfo->Phpm,1)){
 312                         pCurrBssInfo->Phpm.buf[0]=0x3;// DS Parameter Set
 313                         pCurrBssInfo->Phpm.buf[1]=1;
 314             if (!(Cap & CAP_IBSS)) // In IBSS use the ch carried in Beacon/Rsp
 315                 pCurrBssInfo->Phpm.buf[2]=LastSetChannel;
 316                         //goto release;
 317                 }
 318 #if ZDCONF_LP_SUPPORT == 1
 319         elemIdx = 1;
 320         while(getElem(rdu, EID_ZYDAS, &tmpElement,elemIdx))
 321         {
 322             //If elemIdx++ doesn't execute, there would be endless loop.
 323             if(loopCheck++ > 100)
 324             {
 325                 printk("infinite loop occurs in %s\n", __FUNCTION__);
 326                 loopCheck = 0;
 327                 break;
 328             }
 329
 330             elemIdx++;
 331             if(tmpElement.buf[2] == (U8)ZDOUI_AMSDU &&
 332                tmpElement.buf[3] == (U8)(ZDOUI_AMSDU >> 8) &&
 333                tmpElement.buf[4] == (U8)(ZDOUI_AMSDU >> 16) )
 334             {
 335                 memcpy(&pCurrBssInfo->zdIE_AMSDU, &tmpElement, sizeof(Element));
 336             }
 337             else if(tmpElement.buf[2] == (U8)ZDOUI_BURST &&
 338                tmpElement.buf[3] == (U8)(ZDOUI_BURST >> 8) &&
 339                tmpElement.buf[4] == (U8)(ZDOUI_BURST >> 16) )
 340             {
 341                 memcpy(&pCurrBssInfo->zdIE_BURST, &tmpElement, sizeof(Element));
 342             }
 343         }
 344 #endif
 345 #if ZDCONF_SES_SUPPORT
 346         elemIdx=1;
 347         while(getElem(rdu, EID_WPA, &(pCurrBssInfo->SES_Element), elemIdx))
 348         {
 349             //if elemIdx++ doesn't execute, endless loop occur
 350             if(loopCheck++ > 100)
 351             {
 352                 printk("infinite loop occurs in %s\n", __FUNCTION__);
 353                 loopCheck = 0;
 354                 break;
 355             }
 356
 357             if(pCurrBssInfo->SES_Element.buf[1] >= 3)
 358             {
 359                 if(memcmp(pCurrBssInfo->SES_Element.buf+2, SES_OUI, sizeof(SES_OUI)) == 0)
 360                 {
 361                     pCurrBssInfo->SES_Element_Valid = TRUE;
 362                     break;
 363                 }
 364             }
 365             elemIdx++;
 366         }
 367 #endif
 368
 369                 //This is used to filter non-allowed channel beacons
 370                 if (!((1 << (pCurrBssInfo->Phpm.buf[2]-1)) & pdot11Obj->AllowedChannel)){
 371                         if(PURE_A_MODE != mMacMode)
 372                                 goto release;
 373                 }
 374
 375                 if (Cap & CAP_IBSS){
 376                         if (!getElem(rdu, EID_IBPARMS, &pCurrBssInfo->IbssParms,1)){
 377                                 goto release;
 378                         }
 379                 }
 380
 381                 if (getElem(rdu, EID_EXT_RATES, &pCurrBssInfo->extRates,1)){
 382                         //zd1205_dump_data("Ext Rates", &pCurrBssInfo->extRates.buf[2], pCurrBssInfo->extRates.buf[1]);
 383                 }
 384
 385                 if (getElem(rdu, EID_ERP, &pCurrBssInfo->erp,1)){
 386                         //zd1205_dump_data("ERP Info", &pCurrBssInfo->erp.buf[2], pCurrBssInfo->erp.buf[1]);
 387                 }
 388                 getElem(rdu, EID_COUNTRY, &pCurrBssInfo->country,1);
 389
 390                 zd_makeRateInfoMAP((U8 *)&pCurrBssInfo->supRates, &pCurrBssInfo->basicRateMap, &pCurrBssInfo->supRateMap);
 391                 zd_makeRateInfoMAP((U8 *)&pCurrBssInfo->extRates, &pCurrBssInfo->basicRateMap, &pCurrBssInfo->supRateMap);
 392                 //FPRINT_V("basicRateMap", pCurrBssInfo->basicRateMap);
 393                 //FPRINT_V("supRateMap", pCurrBssInfo->supRateMap);
 394
 395                 if (LastMacMode != PURE_A_MODE && pCurrBssInfo->supRateMap > 0x0f){  //support rates include OFDM rates
 396                         if (pCurrBssInfo->basicRateMap & ~0xf){ // basic rates include OFDM rates
 397                                 pCurrBssInfo->apMode = PURE_G_AP;
 398                                 //FPRINT("PURE_G_AP");
 399                         }
 400                         else {
 401                                 pCurrBssInfo->apMode = MIXED_AP;
 402                                 //FPRINT("MIXED_AP");
 403                         }
 404                 }
 405                 else if(LastMacMode == PURE_A_MODE) {
 406                         pCurrBssInfo->apMode = PURE_A_AP;
 407                 }
 408                 else {
 409                         pCurrBssInfo->apMode = PURE_B_AP;
 410                         //FPRINT("PURE_B_AP");
 411                 }
 412
 413                 /* Get WPA IE Information */
 414                 //getElem(rdu, EID_WPA, (Element *)&pCurrBssInfo->WPAIe);
 415
 416             memset(&pCurrBssInfo->WPAIe,0x00, sizeof(pCurrBssInfo->WPAIe));
 417         elemIdx=1;
 418             while(getElem(rdu, EID_WPA, (Element*)&pCurrBssInfo->WPAIe,elemIdx))
 419         {
 420             //if elemIdx++ doesn't execute, endless loop occur
 421             if(loopCheck++ > 100)
 422             {
 423                 printk("infinite loop occurs in %s\n", __FUNCTION__);
 424                 loopCheck = 0;
 425                 break;
 426             }
 427
 428             if((memcmp(pCurrBssInfo->WPAIe+2,WPA_OUI, sizeof(WPA_OUI)) != 0) ||
 429                (pCurrBssInfo->WPAIe[1] < 20) )
 430             {
 431                 memset(&pCurrBssInfo->WPAIe,0x00, sizeof(pCurrBssInfo->WPAIe));
 432             }
 433             else
 434                 break;
 435
 436             elemIdx++;
 437         }
 438
 439         memset(&pCurrBssInfo->RSNIe,0x00, sizeof(pCurrBssInfo->RSNIe));
 440             getElem(rdu, EID_RSN, (Element*)&pCurrBssInfo->RSNIe,1);
 441
 442
 443                 #if 0
 444                 /* Dump WPA IE */
 445                 if(pCurrBssInfo->WPAIe[1] != 0) {
 446                         int ii;
 447                         u8 SSID[34];
 448
 449                         memcpy(SSID, (u8 *)(&pCurrBssInfo->ssid.buf[2]), pCurrBssInfo->ssid.buf[1]);
 450                         SSID[pCurrBssInfo->ssid.buf[1]] = '\0';
 451
 452                         printk(KERN_ERR "WPA IE found in site survey, SSID: %s\n", SSID);
 453
 454                         for(ii = 0; ii < pCurrBssInfo->WPAIe[1]+2; ) {
 455                                 printk(KERN_ERR "0x%02x ", pCurrBssInfo->WPAIe[ii]);
 456                                 ii++;
 457                         }
 458
 459                         printk(KERN_ERR "\n");
 460                 }
 461                 #endif
 462
 463                 pCurrBssInfo->signalStrength = pfrmDesc->signalStrength;
 464                 pCurrBssInfo->signalQuality = pfrmDesc->signalQuality;
 465
 466                 if (mBssNum < 63){
 467                         if (!bUpdateInfo)
 468                                 mBssNum++;
 469                 }
 470         }
 471
 472 release:
 473         ZDEBUG("goto release");
 474         freeFdesc(pfrmDesc);
 475         return TRUE;
 476 }
 477
 478
 479 BOOLEAN SynchEntry(Signal_t *signal)
 480 {
 481         FrmDesc_t *pfrmDesc;
 482
 483         switch(signal->id){
 484                 case SIG_PROBE:
 485                         return Probe(signal);
 486
 487                 case SIG_PROBE_REQ:
 488                         return ProbeReq(signal);
 489
 490                 case SIQ_PROBE_RSP_BEACON:
 491                         return ProbeRsp_Beacon(signal);
 492
 493                 default:
 494                         goto sync_discard;
 495         }
 496
 497 sync_discard:
 498         pfrmDesc = signal->frmInfo.frmDesc;
 499         freeFdesc(pfrmDesc);
 500         return TRUE;
 501 }
 502 #endif
 503