release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/staging/otus/80211core/cic.c

   1 /*
   2  * Copyright (c) 2007-2008 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "cprecomp.h"
  18 #include "ratectrl.h"
  19
  20
  21 void zfUpdateBssid(zdev_t* dev, u8_t* bssid)
  22 {
  23
  24     zmw_get_wlan_dev(dev);
  25
  26     //zmw_declare_for_critical_section();
  27
  28     //zmw_enter_critical_section(dev);
  29     wd->sta.bssid[0] = bssid[0] + (((u16_t) bssid[1]) << 8);
  30     wd->sta.bssid[1] = bssid[2] + (((u16_t) bssid[3]) << 8);
  31     wd->sta.bssid[2] = bssid[4] + (((u16_t) bssid[5]) << 8);
  32     //zmw_leave_critical_section(dev);
  33
  34     zfHpSetBssid(dev, bssid);
  35
  36 }
  37
  38 /************************************************************************************/
  39 /*                                                                                  */
  40 /*    FUNCTION DESCRIPTION                  zfResetSupportRate                      */
  41 /*      Reset support rate to default value.                                        */
  42 /*                                                                                  */
  43 /*    INPUTS                                                                        */
  44 /*      dev : device pointer                                                        */
  45 /*      type: ZM_DEFAULT_SUPPORT_RATE_ZERO       => reset to zero                   */
  46 /*            ZM_DEFAULT_SUPPORT_RATE_DISCONNECT => reset to disconnect status      */
  47 /*            ZM_DEFAULT_SUPPORT_RATE_IBSS_B     => reset to IBSS creator(b mode)   */
  48 /*            ZM_DEFAULT_SUPPORT_RATE_IBSS_AG    => reset to IBSS creator(a/g mode) */
  49 /*                                                                                  */
  50 /************************************************************************************/
  51 void zfResetSupportRate(zdev_t* dev, u8_t type)
  52 {
  53     zmw_get_wlan_dev(dev);
  54
  55     switch(type)
  56     {
  57     case ZM_DEFAULT_SUPPORT_RATE_ZERO:
  58         wd->bRate = 0;
  59         wd->bRateBasic = 0;
  60         wd->gRate = 0;
  61         wd->gRateBasic = 0;
  62         break;
  63     case ZM_DEFAULT_SUPPORT_RATE_DISCONNECT:
  64         wd->bRate = 0xf;
  65         wd->bRateBasic = 0xf;
  66         wd->gRate = 0xff;
  67         wd->gRateBasic = 0x15;
  68         break;
  69     case ZM_DEFAULT_SUPPORT_RATE_IBSS_B:
  70         wd->bRate = 0xf;
  71         wd->bRateBasic = 0xf;
  72         wd->gRate = 0;
  73         wd->gRateBasic = 0;
  74         break;
  75     case ZM_DEFAULT_SUPPORT_RATE_IBSS_AG:
  76         wd->bRate = 0xf;
  77         wd->bRateBasic = 0xf;
  78         wd->gRate = 0xff;
  79         wd->gRateBasic = 0;
  80         break;
  81     }
  82 }
  83
  84 void zfUpdateSupportRate(zdev_t* dev, u8_t* rateArray)
  85 {
  86     u8_t bRate=0, bRateBasic=0, gRate=0, gRateBasic=0;
  87     u8_t length = rateArray[1];
  88     u8_t i, j;
  89
  90     zmw_get_wlan_dev(dev);
  91
  92     for(i=2; i<length+2; i++)
  93     {
  94         for(j=0; j<4; j++)
  95         {
  96             if ( (rateArray[i] & 0x7f) == zg11bRateTbl[j] )
  97             {
  98                 bRate |= (1 << j);
  99                 if ( rateArray[i] & 0x80 )
 100                 {
 101                     bRateBasic |= (1 << j);
 102                 }
 103             }
 104         }
 105
 106         if ( j == 4 )
 107         {
 108             for(j=0; j<8; j++)
 109             {
 110                 if ( (rateArray[i] & 0x7f) == zg11gRateTbl[j] )
 111                 {
 112                     gRate |= (1 << j);
 113                     if ( rateArray[i] & 0x80 )
 114                     {
 115                         gRateBasic |= (1 << j);
 116                     }
 117                 }
 118             }
 119         }
 120     }
 121
 122
 123     wd->bRate |= bRate;
 124     wd->bRateBasic |= bRateBasic;
 125     wd->gRate |= gRate;
 126     wd->gRateBasic |= gRateBasic;
 127 }
 128
 129 u8_t zfIsGOnlyMode(zdev_t* dev, u16_t  frequency, u8_t* rateArray)
 130 {
 131     u8_t length = rateArray[1];
 132     u8_t i, j;
 133
 134     if (frequency < 3000) {
 135         for (i = 2; i < length+2; i++) {
 136             for (j = 0; j < 8; j++) {
 137                 if ( ((rateArray[i] & 0x7f) == zg11gRateTbl[j])
 138                      && (rateArray[i] & 0x80) ) {
 139                     return 1;
 140                 }
 141             }
 142         }
 143     }
 144
 145     return 0;
 146 }
 147
 148 void zfGatherBMode(zdev_t* dev, u8_t* rateArray, u8_t* extrateArray)
 149 {
 150     u8_t gatherBMode[ZM_MAX_SUPP_RATES_IE_SIZE + 2];
 151     u8_t i, j, k = 0;
 152     u8_t length;
 153
 154     gatherBMode[0] = ZM_WLAN_EID_SUPPORT_RATE;
 155     gatherBMode[1] = 0;
 156
 157     length = rateArray[1];
 158     for (i = 2; i < length+2; i++) {
 159         for (j = 0; j < 4; j++) {
 160             if ( (rateArray[i] & 0x7f) == zg11bRateTbl[j] ) {
 161                 gatherBMode[2+k] = rateArray[i];
 162
 163                 gatherBMode[1]++;
 164                 k++;
 165             }
 166         }
 167     }
 168
 169     length = extrateArray[1];
 170     for (i = 2; i < length+2; i++) {
 171         for (j = 0; j < 4; j++) {
 172             if ( (extrateArray[i] & 0x7f) == zg11bRateTbl[j] ) {
 173                 gatherBMode[2+k] = extrateArray[i];
 174
 175                 gatherBMode[1]++;
 176                 k++;
 177             }
 178         }
 179     }
 180
 181     extrateArray[0] = extrateArray[1] = 0;
 182     zfMemoryCopy(rateArray, gatherBMode, gatherBMode[1]+2);
 183 }
 184
 185 u16_t zfGetRandomNumber(zdev_t* dev, u16_t initValue)
 186 {
 187     return 0;
 188 }
 189
 190 u8_t zfPSDeviceSleep(zdev_t* dev)
 191 {
 192     //zmw_get_wlan_dev(dev);
 193
 194     /* enter PS mode */
 195
 196     return 0;
 197 }
 198
 199 u8_t zcOfdmPhyCrtlToRate[] =
 200 {
 201     /* 0x8=48M, 0x9=24M, 0xa=12M, 0xb=6M, 0xc=54M, 0xd=36M, 0xe=18M, 0xf=9M */
 202             10,       8,       6,      4,      11,       9,       7,      5
 203 };
 204
 205 u8_t zfPhyCtrlToRate(u32_t phyCtrl)
 206 {
 207     u32_t mt, mcs, sg;
 208     u8_t rate = 0;
 209
 210     mt = phyCtrl & 0x3;
 211     mcs = (phyCtrl>>18) & 0x3f;
 212     sg = (phyCtrl>>31) & 0x1;
 213
 214     if ((mt == 0) && (mcs <=3))
 215     {
 216         rate = (u8_t)mcs;
 217     }
 218     else if ((mt == 1) && (mcs >= 0x8) && (mcs <= 0xf))
 219     {
 220         rate = zcOfdmPhyCrtlToRate[mcs-8];
 221     }
 222     else if ((mt == 2) && (mcs <= 15))
 223     {
 224         rate = (u8_t)mcs + 12;
 225         if(sg) {
 226             if (mcs != 7)
 227             {
 228                 rate = (u8_t)mcs + 12 + 2;
 229             }
 230             else //MCS7-SG
 231             {
 232                 rate = (u8_t)30;
 233             }
 234         }
 235     }
 236
 237     return rate;
 238 }
 239
 240
 241 void zfCoreEvent(zdev_t* dev, u16_t event, u8_t* rsp)
 242 {
 243     u16_t i;
 244     zbuf_t* psBuf;
 245     u8_t moreData;
 246     u8_t vap = 0;
 247     u8_t peerIdx;
 248     s8_t res;
 249     zmw_get_wlan_dev(dev);
 250     zmw_declare_for_critical_section();
 251
 252
 253     if (event == 0) //Beacon Event
 254     {
 255         if ( wd->wlanMode == ZM_MODE_AP )
 256         {
 257             zfApSendBeacon(dev);
 258
 259             if (wd->CurrentDtimCount == 0)
 260             {
 261                 /* TODO : Send queued broadcast frames at BC/MC event */
 262                 do
 263                 {
 264                     psBuf = NULL;
 265                     moreData = 0;
 266                     zmw_enter_critical_section(dev);
 267                     if (wd->ap.bcmcTail[vap] != wd->ap.bcmcHead[vap])
 268                     {
 269                         //zm_msg0_mm(ZM_LV_0, "Send BCMC frames");
 270                         psBuf = wd->ap.bcmcArray[vap][wd->ap.bcmcHead[vap]];
 271                         wd->ap.bcmcHead[vap] = (wd->ap.bcmcHead[vap] + 1)
 272                                 & (ZM_BCMC_ARRAY_SIZE - 1);
 273                         if (wd->ap.bcmcTail[vap] != wd->ap.bcmcHead[vap])
 274                         {
 275                             moreData = 0x20;
 276                         }
 277                     }
 278                     zmw_leave_critical_section(dev);
 279                     if (psBuf != NULL)
 280                     {
 281                         /* TODO : config moreData bit */
 282                         zfTxSendEth(dev, psBuf, 0, ZM_EXTERNAL_ALLOC_BUF,
 283                                 moreData);
 284                     }
 285                 } while(psBuf != NULL);
 286
 287             }
 288         }
 289         else
 290         {
 291             /* STA mode */
 292             if ( wd->sta.powerSaveMode > ZM_STA_PS_NONE )
 293             {
 294                 /* send queued packets */
 295                 for(i=0; i<wd->sta.staPSDataCount; i++)
 296                 {
 297                     zfTxSendEth(dev, wd->sta.staPSDataQueue[i], 0,
 298                                 ZM_EXTERNAL_ALLOC_BUF, 0);
 299                 }
 300
 301                 wd->sta.staPSDataCount = 0;
 302             }
 303
 304             if ( wd->wlanMode == ZM_MODE_IBSS )
 305             {
 306                 zfStaSendBeacon(dev);
 307                 wd->sta.ibssAtimTimer = ZM_BIT_15 | wd->sta.atimWindow;
 308             }
 309
 310             zfPowerSavingMgrPreTBTTInterrupt(dev);
 311         }
 312     } //if (event == 0) //Beacon Event
 313     else if (event == 1) //Retry completed event
 314     {
 315         u32_t retryRate;
 316
 317         retryRate = (u32_t)(rsp[6]) + (((u32_t)(rsp[7]))<<8)
 318                 + (((u32_t)(rsp[8]))<<16) + (((u32_t)(rsp[9]))<<24);
 319         /* Degrade Tx Rate */
 320         if (wd->wlanMode == ZM_MODE_AP)
 321         {
 322             zmw_enter_critical_section(dev);
 323             i = zfApFindSta(dev, (u16_t*)rsp);
 324             if (i != 0xffff)
 325             {
 326                 zfRateCtrlTxFailEvent(dev, &wd->ap.staTable[i].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate));
 327             }
 328             zmw_leave_critical_section(dev);
 329         }
 330         else
 331         {
 332             zmw_enter_critical_section(dev);
 333             res = zfStaFindOppositeByMACAddr(dev, (u16_t*)rsp, &peerIdx);
 334             if ( res == 0 )
 335             {
 336                 zfRateCtrlTxFailEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate));
 337             }
 338             zmw_leave_critical_section(dev);
 339         }
 340     } //else if (event == 1) //Retry completed event
 341     else if (event == 2) //Tx Fail event
 342     {
 343         u32_t retryRate;
 344
 345         retryRate = (u32_t)(rsp[6]) + (((u32_t)(rsp[7]))<<8)
 346                 + (((u32_t)(rsp[8]))<<16) + (((u32_t)(rsp[9]))<<24);
 347
 348         /* Degrade Tx Rate */
 349         if (wd->wlanMode == ZM_MODE_AP)
 350         {
 351             zmw_enter_critical_section(dev);
 352             i = zfApFindSta(dev, (u16_t*)rsp);
 353             if (i != 0xffff)
 354             {
 355                 zfRateCtrlTxFailEvent(dev, &wd->ap.staTable[i].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate));
 356             }
 357             zmw_leave_critical_section(dev);
 358
 359             zfApSendFailure(dev, rsp);
 360         }
 361         else
 362         {
 363             zmw_enter_critical_section(dev);
 364             res = zfStaFindOppositeByMACAddr(dev, (u16_t*)rsp, &peerIdx);
 365             if ( res == 0 )
 366             {
 367                 zfRateCtrlTxFailEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate));
 368             }
 369             zmw_leave_critical_section(dev);
 370         }
 371     } //else if (event == 2) //Tx Fail event
 372     else if (event == 3) //Tx Comp event
 373     {
 374         u32_t retryRate;
 375
 376         retryRate = (u32_t)(rsp[6]) + (((u32_t)(rsp[7]))<<8)
 377                 + (((u32_t)(rsp[8]))<<16) + (((u32_t)(rsp[9]))<<24);
 378
 379         /* TODO : Tx completed, used for rate control probing */
 380         if (wd->wlanMode == ZM_MODE_AP)
 381         {
 382             zmw_enter_critical_section(dev);
 383             i = zfApFindSta(dev, (u16_t*)rsp);
 384             if (i != 0xffff)
 385             {
 386                 zfRateCtrlTxSuccessEvent(dev, &wd->ap.staTable[i].rcCell, zfPhyCtrlToRate(retryRate));
 387             }
 388             zmw_leave_critical_section(dev);
 389         }
 390         else
 391         {
 392             zmw_enter_critical_section(dev);
 393             res = zfStaFindOppositeByMACAddr(dev, (u16_t*)rsp, &peerIdx);
 394             if ( res == 0 )
 395             {
 396                 zfRateCtrlTxSuccessEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, zfPhyCtrlToRate(retryRate));
 397             }
 398             zmw_leave_critical_section(dev);
 399         }
 400     } //else if (event == 3) //Tx Comp event
 401     else if (event == 4) //BA failed count
 402     {
 403         u32_t fail;
 404         u32_t rate;
 405         peerIdx = 0;
 406
 407         fail=((u32_t*)rsp)[0] & 0xFFFF;
 408         rate=((u32_t*)rsp)[0] >> 16;
 409
 410         if (rate > 15) {
 411             rate = (rate & 0xF) + 12 + 2;
 412         }
 413         else {
 414             rate = rate + 12;
 415         }
 416
 417         zmw_enter_critical_section(dev);
 418         zfRateCtrlTxFailEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, (u8_t)rate, fail);
 419         zmw_leave_critical_section(dev);
 420     }
 421 }
 422
 423 void zfBeaconCfgInterrupt(zdev_t* dev, u8_t* rsp)
 424 {
 425     u32_t txBeaconCounter;
 426
 427     zmw_get_wlan_dev(dev);
 428
 429     zmw_declare_for_critical_section();
 430
 431     if ( wd->wlanMode == ZM_MODE_IBSS )
 432     {
 433         txBeaconCounter = *((u32_t *)rsp);
 434         if ( wd->sta.beaconTxCnt != txBeaconCounter )
 435         {
 436             wd->sta.txBeaconInd = 1;
 437
 438             zmw_enter_critical_section(dev);
 439             wd->tickIbssSendBeacon = 0;
 440             zmw_leave_critical_section(dev);
 441         }
 442         else
 443         {
 444             wd->sta.txBeaconInd = 0;
 445         }
 446
 447 #ifdef ZM_ENABLE_IBSS_DELAYED_JOIN_INDICATION
 448         if ( wd->sta.txBeaconInd && wd->sta.ibssDelayedInd )
 449         {
 450             if (wd->zfcbIbssPartnerNotify != NULL)
 451             {
 452                 wd->zfcbIbssPartnerNotify(dev, 1, &wd->sta.ibssDelayedIndEvent);
 453             }
 454
 455             wd->sta.ibssDelayedInd = 0;
 456         }
 457 #endif
 458
 459         wd->sta.beaconTxCnt = txBeaconCounter;
 460
 461         // Need to check if the time is expired after ATIM window??
 462
 463         // Check if we have buffered any data for those stations that are sleeping
 464         // If it's true, then transmitting ATIM pkt to notify them
 465
 466 #ifdef ZM_ENABLE_IBSS_PS
 467         // TODO: Need to check if the station receive our ATIM pkt???
 468         zfStaIbssPSSend(dev);
 469
 470         if ( wd->sta.atimWindow == 0 )
 471         {
 472             // We won't receive the end of ATIM isr so we fake it
 473             zfPowerSavingMgrAtimWinExpired(dev);
 474         }
 475 #endif
 476     }
 477 }
 478
 479 void zfEndOfAtimWindowInterrupt(zdev_t* dev)
 480 {
 481 #ifdef ZM_ENABLE_IBSS_PS
 482     zmw_get_wlan_dev(dev);
 483
 484     if ( wd->wlanMode == ZM_MODE_IBSS )
 485     {
 486         // Transmit any queued pkt for the stations!!
 487         zfPowerSavingMgrAtimWinExpired(dev);
 488     }
 489 #endif
 490 }