1 /*

     2  * rate.c

     3  *

     4  * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.      

     5  * All rights reserved.      

     6  * 

     7  * This program and the accompanying materials are made available under the 

     8  * terms of the Eclipse Public License v1.0 or BSD License which accompanies

     9  * this distribution. The Eclipse Public License is available at

    10  * http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.                                   

    11  *                                                                       

    12  * Redistribution and use in source and binary forms, with or without    

    13  * modification, are permitted provided that the following conditions    

    14  * are met:                                                              

    15  *                                                                       

    16  *  * Redistributions of source code must retain the above copyright     

    17  *    notice, this list of conditions and the following disclaimer.      

    18  *  * Redistributions in binary form must reproduce the above copyright  

    19  *    notice, this list of conditions and the following disclaimer in    

    20  *    the documentation and/or other materials provided with the         

    21  *    distribution.                                                      

    22  *  * Neither the name Texas Instruments nor the names of its            

    23  *    contributors may be used to endorse or promote products derived    

    24  *    from this software without specific prior written permission.      

    25  *                                                                       

    26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   

    27  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     

    28  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 

    29  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  

    30  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

    31  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      

    32  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 

    33  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 

    34  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT   

    35  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 

    36  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    37  */

    38 

    39 

    40 /** \file  rate.c

    41  *  \brief Rate conversion

    42  *

    43  *  \see   rate.h

    44  */

    45 #define __FILE_ID__  FILE_ID_131

    46 #include "tidef.h"

    47 #include "rate.h"

    48 

    49 

    50 

    51 ERate rate_NetToDrv (TI_UINT32 rate)

    52 {

    53     switch (rate)

    54     {

    55         case NET_RATE_1M:

    56         case NET_RATE_1M_BASIC:

    57             return DRV_RATE_1M;

    58 

    59         case NET_RATE_2M:

    60         case NET_RATE_2M_BASIC:

    61             return DRV_RATE_2M;

    62 

    63         case NET_RATE_5_5M:

    64         case NET_RATE_5_5M_BASIC:

    65             return DRV_RATE_5_5M;

    66 

    67         case NET_RATE_11M:

    68         case NET_RATE_11M_BASIC:

    69             return DRV_RATE_11M;

    70 

    71         case NET_RATE_22M:

    72         case NET_RATE_22M_BASIC:

    73             return DRV_RATE_22M;

    74 

    75         case NET_RATE_6M:

    76         case NET_RATE_6M_BASIC:

    77             return DRV_RATE_6M;

    78 

    79         case NET_RATE_9M:

    80         case NET_RATE_9M_BASIC:

    81             return DRV_RATE_9M;

    82 

    83         case NET_RATE_12M:

    84         case NET_RATE_12M_BASIC:

    85             return DRV_RATE_12M;

    86 

    87         case NET_RATE_18M:

    88         case NET_RATE_18M_BASIC:

    89             return DRV_RATE_18M;

    90 

    91         case NET_RATE_24M:

    92         case NET_RATE_24M_BASIC:

    93             return DRV_RATE_24M;

    94 

    95         case NET_RATE_36M:

    96         case NET_RATE_36M_BASIC:

    97             return DRV_RATE_36M;

    98 

    99         case NET_RATE_48M:

   100         case NET_RATE_48M_BASIC:

   101             return DRV_RATE_48M;

   102 

   103         case NET_RATE_54M:

   104         case NET_RATE_54M_BASIC:

   105             return DRV_RATE_54M;

   106 

   107         case NET_RATE_MCS0:

   108         case NET_RATE_MCS0_BASIC:

   109             return DRV_RATE_MCS_0;

   110 

   111         case NET_RATE_MCS1:

   112         case NET_RATE_MCS1_BASIC:

   113             return DRV_RATE_MCS_1;

   114 

   115         case NET_RATE_MCS2:

   116         case NET_RATE_MCS2_BASIC:

   117             return DRV_RATE_MCS_2;

   118 

   119         case NET_RATE_MCS3:

   120         case NET_RATE_MCS3_BASIC:

   121             return DRV_RATE_MCS_3;

   122 

   123         case NET_RATE_MCS4:

   124         case NET_RATE_MCS4_BASIC:

   125             return DRV_RATE_MCS_4;

   126 

   127         case NET_RATE_MCS5:

   128         case NET_RATE_MCS5_BASIC:

   129             return DRV_RATE_MCS_5;

   130 

   131         case NET_RATE_MCS6:

   132         case NET_RATE_MCS6_BASIC:

   133             return DRV_RATE_MCS_6;

   134 

   135         case NET_RATE_MCS7:

   136         case NET_RATE_MCS7_BASIC:

   137             return DRV_RATE_MCS_7;

   138 

   139         default:

   140             return DRV_RATE_INVALID;

   141     }

   142 }

   143 

   144 /************************************************************************

   145  *                        hostToNetworkRate                         *

   146  ************************************************************************

   147 DESCRIPTION: Translates a host rate (1, 2, 3, ....) to network rate (0x02, 0x82, 0x84, etc...) 

   148                                                                                                    

   149 INPUT:      rate        -   Host rate

   150 

   151 OUTPUT:     

   152 

   153 

   154 RETURN:     Network rate if the input rate is valid, otherwise returns 0.

   155 

   156 ************************************************************************/

   157 ENetRate rate_DrvToNet (ERate rate)

   158 {

   159     switch (rate)

   160     {

   161         case DRV_RATE_AUTO:

   162             return NET_BASIC_MASK;

   163 

   164         case DRV_RATE_1M:

   165             return NET_RATE_1M;

   166 

   167         case DRV_RATE_2M:

   168             return NET_RATE_2M;

   169 

   170         case DRV_RATE_5_5M:

   171             return NET_RATE_5_5M;

   172 

   173         case DRV_RATE_11M:

   174             return NET_RATE_11M;

   175 

   176         case DRV_RATE_22M:

   177             return NET_RATE_22M;

   178 

   179         case DRV_RATE_6M:

   180             return NET_RATE_6M;

   181 

   182         case DRV_RATE_9M:

   183             return NET_RATE_9M;

   184 

   185         case DRV_RATE_12M:

   186             return NET_RATE_12M;

   187 

   188         case DRV_RATE_18M:

   189             return NET_RATE_18M;

   190 

   191         case DRV_RATE_24M:

   192             return NET_RATE_24M;

   193 

   194         case DRV_RATE_36M:

   195             return NET_RATE_36M;

   196 

   197         case DRV_RATE_48M:

   198             return NET_RATE_48M;

   199 

   200         case DRV_RATE_54M:

   201             return NET_RATE_54M;

   202 

   203         case DRV_RATE_MCS_0:

   204             return NET_RATE_MCS0;

   205 

   206         case DRV_RATE_MCS_1:

   207             return NET_RATE_MCS1;

   208     

   209         case DRV_RATE_MCS_2:

   210             return NET_RATE_MCS2;

   211     

   212         case DRV_RATE_MCS_3:

   213             return NET_RATE_MCS3;

   214     

   215         case DRV_RATE_MCS_4:

   216             return NET_RATE_MCS4;

   217     

   218         case DRV_RATE_MCS_5:

   219             return NET_RATE_MCS5;

   220     

   221         case DRV_RATE_MCS_6:

   222             return NET_RATE_MCS6;

   223     

   224         case DRV_RATE_MCS_7:

   225             return NET_RATE_MCS7;

   226 

   227         default:

   228             return NET_BASIC_MASK;

   229     }

   230 }

   231 

   232 /***************************************************************************

   233 *                   getMaxActiveRatefromBitmap                             *

   234 ****************************************************************************

   235 * DESCRIPTION:  

   236 *

   237 * INPUTS:       hCtrlData - the object

   238 *               

   239 * OUTPUT:       

   240 *

   241 * RETURNS:      

   242 ***************************************************************************/

   243 ERate rate_GetMaxFromDrvBitmap (TI_UINT32 uRateBitMap)

   244 {

   245     if (uRateBitMap & DRV_RATE_MASK_MCS_7_OFDM)

   246     {

   247         return DRV_RATE_MCS_7;

   248     }

   249 

   250     if (uRateBitMap & DRV_RATE_MASK_MCS_6_OFDM)

   251     {

   252         return DRV_RATE_MCS_6;

   253     }

   254 

   255     if (uRateBitMap & DRV_RATE_MASK_MCS_5_OFDM)

   256     {

   257         return DRV_RATE_MCS_5;

   258     }

   259 

   260     if (uRateBitMap & DRV_RATE_MASK_MCS_4_OFDM)

   261     {

   262         return DRV_RATE_MCS_4;

   263     }

   264 

   265     if (uRateBitMap & DRV_RATE_MASK_MCS_3_OFDM)

   266     {

   267         return DRV_RATE_MCS_3;

   268     }

   269 

   270     if (uRateBitMap & DRV_RATE_MASK_MCS_2_OFDM)

   271     {

   272         return DRV_RATE_MCS_2;

   273     }

   274 

   275     if (uRateBitMap & DRV_RATE_MASK_MCS_1_OFDM)

   276     {

   277         return DRV_RATE_MCS_1;

   278     }

   279 

   280     if (uRateBitMap & DRV_RATE_MASK_MCS_0_OFDM)

   281     {

   282         return DRV_RATE_MCS_0;

   283     }

   284 

   285     if (uRateBitMap & DRV_RATE_MASK_54_OFDM)

   286     {

   287         return DRV_RATE_54M;

   288     }

   289 

   290     if (uRateBitMap & DRV_RATE_MASK_48_OFDM)

   291     {

   292         return DRV_RATE_48M;

   293     }

   294 

   295     if (uRateBitMap & DRV_RATE_MASK_36_OFDM)

   296     {

   297         return DRV_RATE_36M;

   298     }

   299 

   300     if (uRateBitMap & DRV_RATE_MASK_24_OFDM)

   301     {

   302         return DRV_RATE_24M;

   303     }

   304 

   305     if (uRateBitMap & DRV_RATE_MASK_22_PBCC)

   306     {

   307         return DRV_RATE_22M;

   308     }

   309 

   310     if (uRateBitMap & DRV_RATE_MASK_18_OFDM)

   311     {

   312         return DRV_RATE_18M;

   313     }

   314 

   315     if (uRateBitMap & DRV_RATE_MASK_12_OFDM)

   316     {

   317         return DRV_RATE_12M;

   318     }

   319 

   320     if (uRateBitMap & DRV_RATE_MASK_11_CCK)

   321     {

   322         return DRV_RATE_11M;

   323     }

   324 

   325     if (uRateBitMap & DRV_RATE_MASK_9_OFDM)

   326     {

   327         return DRV_RATE_9M;

   328     }

   329 

   330     if (uRateBitMap & DRV_RATE_MASK_6_OFDM)

   331     {

   332         return DRV_RATE_6M;

   333     }

   334 

   335     if (uRateBitMap & DRV_RATE_MASK_5_5_CCK)

   336     {

   337         return DRV_RATE_5_5M;

   338     }

   339 

   340     if (uRateBitMap & DRV_RATE_MASK_2_BARKER)

   341     {

   342         return DRV_RATE_2M;

   343     }

   344 

   345     if (uRateBitMap & DRV_RATE_MASK_1_BARKER)

   346     {

   347         return DRV_RATE_1M;

   348     }

   349 

   350     return DRV_RATE_INVALID;

   351 }

   352 

   353 /************************************************************************

   354  *                        validateNetworkRate                           *

   355  ************************************************************************

   356 DESCRIPTION: Verify that the input nitwork rate is valid

   357                                                                                                    

   358 INPUT:      rate    -   input network rate

   359 

   360 OUTPUT:     

   361 

   362 

   363 RETURN:     TI_OK if valid, otherwise TI_NOK

   364 

   365 ************************************************************************/

   366 static TI_STATUS rate_ValidateNet (ENetRate eRate)

   367 {

   368     switch (eRate)

   369     {

   370         case NET_RATE_1M:

   371         case NET_RATE_1M_BASIC:

   372         case NET_RATE_2M:

   373         case NET_RATE_2M_BASIC:

   374         case NET_RATE_5_5M:

   375         case NET_RATE_5_5M_BASIC:

   376         case NET_RATE_11M:

   377         case NET_RATE_11M_BASIC:

   378         case NET_RATE_22M:

   379         case NET_RATE_22M_BASIC:

   380         case NET_RATE_6M:

   381         case NET_RATE_6M_BASIC:

   382         case NET_RATE_9M:

   383         case NET_RATE_9M_BASIC:

   384         case NET_RATE_12M:

   385         case NET_RATE_12M_BASIC:

   386         case NET_RATE_18M:

   387         case NET_RATE_18M_BASIC:

   388         case NET_RATE_24M:

   389         case NET_RATE_24M_BASIC:

   390         case NET_RATE_36M:

   391         case NET_RATE_36M_BASIC:

   392         case NET_RATE_48M:

   393         case NET_RATE_48M_BASIC:

   394         case NET_RATE_54M:

   395         case NET_RATE_54M_BASIC:

   396             return TI_OK;

   397 

   398         default:

   399             return TI_NOK;

   400     }

   401 }

   402 

   403 /************************************************************************

   404  *                        getMaxBasicRate                           *

   405  ************************************************************************

   406 DESCRIPTION: Goes over an array of network rates and returns the max basic rate

   407                                                                                                    

   408 INPUT:      pRates      -   Rate array

   409 

   410 OUTPUT:     

   411 

   412 

   413 RETURN:     Max basic rate (in network units)

   414 

   415 ************************************************************************/

   416 ENetRate rate_GetMaxBasicFromStr (TI_UINT8 *pRatesString, TI_UINT32 len, ENetRate eMaxRate)

   417 {

   418     TI_UINT32   i;

   419     

   420     for (i = 0; i < len; i++)

   421     {

   422         if (NET_BASIC_RATE (pRatesString[i]) && rate_ValidateNet ((ENetRate)pRatesString[i]) == TI_OK)

   423         {

   424             eMaxRate = (ENetRate)(TI_MAX (pRatesString[i], eMaxRate));

   425         }

   426     }

   427 

   428     return eMaxRate;

   429 }

   430 

   431 /************************************************************************

   432  *                        getMaxActiveRate                          *

   433  ************************************************************************

   434 DESCRIPTION: Goes over an array of network rates and returns the max active rate

   435                                                                                                    

   436 INPUT:      pRates      -   Rate array

   437 

   438 OUTPUT:     

   439 

   440 

   441 RETURN:     Max active rate (in network units)

   442 

   443 ************************************************************************/

   444 ENetRate rate_GetMaxActiveFromStr (TI_UINT8 *pRatesString, TI_UINT32 len, ENetRate eMaxRate)

   445 {

   446     TI_UINT32   i;

   447     

   448     for (i = 0; i < len; i++)

   449     {

   450         if (NET_ACTIVE_RATE (pRatesString[i]) && rate_ValidateNet ((ENetRate)pRatesString[i]) == TI_OK)

   451         {

   452             eMaxRate = (ENetRate)(TI_MAX (pRatesString[i], eMaxRate));

   453         }

   454     }

   455 

   456     return eMaxRate;

   457 }

   458 

   459 TI_UINT32 rate_DrvToNumber (ERate eRate)

   460 {

   461     switch (eRate)

   462     {

   463         case DRV_RATE_1M:

   464             return 1;

   465 

   466         case DRV_RATE_2M:

   467             return 2;

   468 

   469         case DRV_RATE_5_5M:

   470             return 5;

   471 

   472         case DRV_RATE_11M:

   473             return 11;

   474 

   475         case DRV_RATE_22M:

   476             return 22;

   477 

   478         case DRV_RATE_6M:

   479             return 6;

   480 

   481         case DRV_RATE_9M:

   482             return 9;

   483 

   484         case DRV_RATE_12M:

   485             return 12;

   486 

   487         case DRV_RATE_18M:

   488             return 18;

   489 

   490         case DRV_RATE_24M:

   491             return 24;

   492 

   493         case DRV_RATE_36M:

   494             return 36;

   495 

   496         case DRV_RATE_48M:

   497             return 48;

   498 

   499         case DRV_RATE_54M:

   500             return 54;

   501 

   502         case DRV_RATE_MCS_0:

   503             return 6;

   504     

   505         case DRV_RATE_MCS_1:

   506             return 13;

   507     

   508         case DRV_RATE_MCS_2:

   509             return 19;

   510     

   511         case DRV_RATE_MCS_3:

   512             return 26;

   513     

   514         case DRV_RATE_MCS_4:

   515             return 39;

   516     

   517         case DRV_RATE_MCS_5:

   518             return 52;

   519     

   520         case DRV_RATE_MCS_6:

   521             return 58;

   522     

   523         case DRV_RATE_MCS_7:

   524             return 65;

   525 

   526         default:

   527             return 0;

   528     }

   529 }

   530 

   531 /************************************************************************

   532  *                        bitMapToNetworkStringRates                    *

   533  ************************************************************************

   534 DESCRIPTION: Converts bit map to the rates string

   535                                                                                                    

   536 INPUT:      suppRatesBitMap     -   bit map of supported rates

   537             basicRatesBitMap    -   bit map of basic rates

   538 

   539 OUTPUT:     string - network format rates array,

   540             len - rates array length

   541             firstOFDMrateLoc - the index of first OFDM rate in the rates array.

   542 

   543 

   544 RETURN:     None

   545 

   546 ************************************************************************/

   547 TI_STATUS rate_DrvBitmapToNetStr (TI_UINT32   uSuppRatesBitMap,

   548                                   TI_UINT32   uBasicRatesBitMap,

   549                                   TI_UINT8    *string,

   550                                   TI_UINT32   *len,

   551                                   TI_UINT32   *pFirstOfdmRate)

   552 {

   553     TI_UINT32   i = 0;

   554     

   555     if (uSuppRatesBitMap & DRV_RATE_MASK_1_BARKER)

   556     {

   557         if (uBasicRatesBitMap & DRV_RATE_MASK_1_BARKER)

   558         {

   559             string[i++] = NET_RATE_1M_BASIC;

   560         }

   561         else

   562         {

   563             string[i++] = NET_RATE_1M;

   564         }

   565     }

   566 

   567     if (uSuppRatesBitMap & DRV_RATE_MASK_2_BARKER)

   568     {

   569         if (uBasicRatesBitMap & DRV_RATE_MASK_2_BARKER)

   570         {

   571             string[i++] = NET_RATE_2M_BASIC;

   572         }

   573         else

   574         {

   575             string[i++] = NET_RATE_2M;

   576         }

   577     }

   578 

   579     if (uSuppRatesBitMap & DRV_RATE_MASK_5_5_CCK)

   580     {

   581         if (uBasicRatesBitMap & DRV_RATE_MASK_5_5_CCK)

   582         {

   583             string[i++] = NET_RATE_5_5M_BASIC;

   584         }

   585         else

   586         {

   587             string[i++] = NET_RATE_5_5M;

   588         }

   589     }

   590 

   591     if (uSuppRatesBitMap & DRV_RATE_MASK_11_CCK)

   592     {

   593         if (uBasicRatesBitMap & DRV_RATE_MASK_11_CCK)

   594         {

   595             string[i++] = NET_RATE_11M_BASIC;

   596         }

   597         else

   598         {

   599             string[i++] = NET_RATE_11M;

   600         }

   601     }

   602 

   603     if (uSuppRatesBitMap & DRV_RATE_MASK_22_PBCC)

   604     {

   605         if (uBasicRatesBitMap & DRV_RATE_MASK_22_PBCC)

   606         {

   607             string[i++] = NET_RATE_22M_BASIC;

   608         }

   609         else

   610         {

   611             string[i++] = NET_RATE_22M;

   612         }

   613     }

   614 

   615     *pFirstOfdmRate = i;

   616     

   617     if (uSuppRatesBitMap & DRV_RATE_MASK_6_OFDM)

   618     {

   619         if (uBasicRatesBitMap & DRV_RATE_MASK_6_OFDM)

   620         {

   621             string[i++] = NET_RATE_6M_BASIC;

   622         }

   623         else

   624         {

   625             string[i++] = NET_RATE_6M;

   626         }

   627     }

   628 

   629     if (uSuppRatesBitMap & DRV_RATE_MASK_9_OFDM)

   630     {

   631         if (uBasicRatesBitMap & DRV_RATE_MASK_9_OFDM)

   632         {

   633             string[i++] = NET_RATE_9M_BASIC;

   634         }

   635         else

   636         {

   637             string[i++] = NET_RATE_9M;

   638         }

   639     }

   640 

   641     if (uSuppRatesBitMap & DRV_RATE_MASK_12_OFDM)

   642     {

   643         if (uBasicRatesBitMap & DRV_RATE_MASK_12_OFDM)

   644         {

   645             string[i++] = NET_RATE_12M_BASIC;

   646         }

   647         else

   648         {

   649             string[i++] = NET_RATE_12M;

   650         }

   651     }

   652 

   653     if (uSuppRatesBitMap & DRV_RATE_MASK_18_OFDM)

   654     {

   655         if (uBasicRatesBitMap & DRV_RATE_MASK_18_OFDM)

   656         {

   657             string[i++] = NET_RATE_18M_BASIC;

   658         }

   659         else

   660         {

   661             string[i++] = NET_RATE_18M;

   662         }

   663     }

   664 

   665     if (uSuppRatesBitMap & DRV_RATE_MASK_24_OFDM)

   666     {

   667         if (uBasicRatesBitMap & DRV_RATE_MASK_24_OFDM)

   668         {

   669             string[i++] = NET_RATE_24M_BASIC;

   670         }

   671         else

   672         {

   673             string[i++] = NET_RATE_24M;

   674         }

   675     }

   676 

   677     if (uSuppRatesBitMap & DRV_RATE_MASK_36_OFDM)

   678     {

   679         if (uBasicRatesBitMap & DRV_RATE_MASK_36_OFDM)

   680         {

   681             string[i++] = NET_RATE_36M_BASIC;

   682         }

   683         else

   684         {

   685             string[i++] = NET_RATE_36M;

   686         }

   687     }

   688 

   689     if (uSuppRatesBitMap & DRV_RATE_MASK_48_OFDM)

   690     {

   691         if (uBasicRatesBitMap & DRV_RATE_MASK_48_OFDM)

   692         {

   693             string[i++] = NET_RATE_48M_BASIC;

   694         }

   695         else

   696         {

   697             string[i++] = NET_RATE_48M;

   698         }

   699     }

   700 

   701     if (uSuppRatesBitMap & DRV_RATE_MASK_54_OFDM)

   702     {

   703         if (uBasicRatesBitMap & DRV_RATE_MASK_54_OFDM)

   704         {

   705             string[i++] = NET_RATE_54M_BASIC;

   706         }

   707         else

   708         {

   709             string[i++] = NET_RATE_54M;

   710         }

   711     }

   712 

   713     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_0_OFDM)

   714     {

   715         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_0_OFDM)

   716         {

   717             string[i++] = NET_RATE_MCS0_BASIC;

   718         }

   719         else

   720         {

   721             string[i++] = NET_RATE_MCS0;

   722         }

   723     }

   724 

   725     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_1_OFDM)

   726     {

   727         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_1_OFDM)

   728         {

   729             string[i++] = NET_RATE_MCS1_BASIC;

   730         }

   731         else

   732         {

   733             string[i++] = NET_RATE_MCS1;

   734         }

   735     }

   736 

   737     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_2_OFDM)

   738     {

   739         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_2_OFDM)

   740         {

   741             string[i++] = NET_RATE_MCS2_BASIC;

   742         }

   743         else

   744         {

   745             string[i++] = NET_RATE_MCS2;

   746         }

   747     }

   748 

   749     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_3_OFDM)

   750     {

   751         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_3_OFDM)

   752         {

   753             string[i++] = NET_RATE_MCS3_BASIC;

   754         }

   755         else

   756         {

   757             string[i++] = NET_RATE_MCS3;

   758         }

   759     }

   760 

   761     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_4_OFDM)

   762     {

   763         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_4_OFDM)

   764         {

   765             string[i++] = NET_RATE_MCS4_BASIC;

   766         }

   767         else

   768         {

   769             string[i++] = NET_RATE_MCS4;

   770         }

   771     }

   772 

   773     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_5_OFDM)

   774     {

   775         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_5_OFDM)

   776         {

   777             string[i++] = NET_RATE_MCS5_BASIC;

   778         }

   779         else

   780         {

   781             string[i++] = NET_RATE_MCS5;

   782         }

   783     }

   784 

   785     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_6_OFDM)

   786     {

   787         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_6_OFDM)

   788         {

   789             string[i++] = NET_RATE_MCS6_BASIC;

   790         }

   791         else

   792         {

   793             string[i++] = NET_RATE_MCS6;

   794         }

   795     }

   796 

   797     if (uSuppRatesBitMap & DRV_RATE_MASK_MCS_7_OFDM)

   798     {

   799         if (uBasicRatesBitMap & DRV_RATE_MASK_MCS_7_OFDM)

   800         {

   801             string[i++] = NET_RATE_MCS7_BASIC;

   802         }

   803         else

   804         {

   805             string[i++] = NET_RATE_MCS7;

   806         }

   807     }

   808 

   809 

   810     *len = i;

   811     

   812     return TI_OK;

   813 }

   814 

   815 /************************************************************************

   816  *                        networkStringToBitMapSuppRates                *

   817  ************************************************************************

   818 DESCRIPTION: Converts supported rates string to the bit map

   819                                                                                                    

   820 INPUT:      string      -   array of rates in the network format

   821             len - array length

   822 

   823 OUTPUT:     bitMap - bit map of rates.

   824 

   825 RETURN:     None

   826 

   827 ************************************************************************/

   828 TI_STATUS rate_NetStrToDrvBitmap (TI_UINT32 *pBitMap, TI_UINT8 *string, TI_UINT32 len)

   829 {

   830     TI_UINT32   i;

   831     

   832     *pBitMap = 0;

   833     

   834     for (i = 0; i < len; i++)

   835     {

   836         switch (string[i])

   837         {

   838             case NET_RATE_1M:

   839             case NET_RATE_1M_BASIC:

   840                 *pBitMap |= DRV_RATE_MASK_1_BARKER;

   841                 break;

   842 

   843             case NET_RATE_2M:

   844             case NET_RATE_2M_BASIC:

   845                 *pBitMap |= DRV_RATE_MASK_2_BARKER;

   846                 break;

   847 

   848             case NET_RATE_5_5M:

   849             case NET_RATE_5_5M_BASIC:

   850                 *pBitMap |= DRV_RATE_MASK_5_5_CCK;

   851                 break;

   852 

   853             case NET_RATE_11M:

   854             case NET_RATE_11M_BASIC:

   855                 *pBitMap |= DRV_RATE_MASK_11_CCK;

   856                 break;

   857 

   858             case NET_RATE_22M:

   859             case NET_RATE_22M_BASIC:

   860                 *pBitMap |= DRV_RATE_MASK_22_PBCC;

   861                 break;

   862 

   863             case NET_RATE_6M:

   864             case NET_RATE_6M_BASIC:

   865                 *pBitMap |= DRV_RATE_MASK_6_OFDM;

   866                 break;

   867 

   868             case NET_RATE_9M:

   869             case NET_RATE_9M_BASIC:

   870                 *pBitMap |= DRV_RATE_MASK_9_OFDM;

   871                 break;

   872 

   873             case NET_RATE_12M:

   874             case NET_RATE_12M_BASIC:

   875                 *pBitMap |= DRV_RATE_MASK_12_OFDM;

   876                 break;

   877 

   878             case NET_RATE_18M:

   879             case NET_RATE_18M_BASIC:

   880                 *pBitMap |= DRV_RATE_MASK_18_OFDM;

   881                 break;

   882 

   883             case NET_RATE_24M:

   884             case NET_RATE_24M_BASIC:

   885                 *pBitMap |= DRV_RATE_MASK_24_OFDM;

   886                 break;

   887 

   888             case NET_RATE_36M:

   889             case NET_RATE_36M_BASIC:

   890                 *pBitMap |= DRV_RATE_MASK_36_OFDM;

   891                 break;

   892 

   893             case NET_RATE_48M:

   894             case NET_RATE_48M_BASIC:

   895                 *pBitMap |= DRV_RATE_MASK_48_OFDM;

   896                 break;

   897 

   898             case NET_RATE_54M:

   899             case NET_RATE_54M_BASIC:

   900                 *pBitMap |= DRV_RATE_MASK_54_OFDM;

   901                 break;

   902 

   903             case NET_RATE_MCS0:

   904             case NET_RATE_MCS0_BASIC:

   905                 *pBitMap |= DRV_RATE_MASK_MCS_0_OFDM;

   906                 break;

   907     

   908             case NET_RATE_MCS1:

   909             case NET_RATE_MCS1_BASIC:

   910                 *pBitMap |= DRV_RATE_MASK_MCS_1_OFDM;

   911                 break;

   912     

   913             case NET_RATE_MCS2:

   914             case NET_RATE_MCS2_BASIC:

   915                 *pBitMap |= DRV_RATE_MASK_MCS_2_OFDM;

   916                 break;

   917     

   918             case NET_RATE_MCS3:

   919             case NET_RATE_MCS3_BASIC:

   920                 *pBitMap |= DRV_RATE_MASK_MCS_3_OFDM;

   921                 break;

   922     

   923             case NET_RATE_MCS4:

   924             case NET_RATE_MCS4_BASIC:

   925                 *pBitMap |= DRV_RATE_MASK_MCS_4_OFDM;

   926                 break;

   927     

   928             case NET_RATE_MCS5:

   929             case NET_RATE_MCS5_BASIC:

   930                 *pBitMap |= DRV_RATE_MASK_MCS_5_OFDM;

   931                 break;

   932     

   933             case NET_RATE_MCS6:

   934             case NET_RATE_MCS6_BASIC:

   935                 *pBitMap |= DRV_RATE_MASK_MCS_6_OFDM;

   936                 break;

   937     

   938             case NET_RATE_MCS7:

   939             case NET_RATE_MCS7_BASIC:

   940                 *pBitMap |= DRV_RATE_MASK_MCS_7_OFDM;

   941                 break;

   942 

   943             default:

   944                 break;

   945         }

   946     }

   947 

   948     return TI_OK;

   949 }

   950 

   951 /************************************************************************

   952  *                        networkStringToBitMapBasicRates               *

   953  ************************************************************************

   954 DESCRIPTION: Converts basic rates string to the bit map

   955                                                                                                    

   956 INPUT:      string      -   array of rates in the network format

   957             len - array length

   958 

   959 OUTPUT:     bitMap - bit map of rates.

   960 

   961 RETURN:     None

   962 

   963 ************************************************************************/

   964 TI_STATUS rate_NetBasicStrToDrvBitmap (TI_UINT32 *pBitMap, TI_UINT8 *string, TI_UINT32 len)

   965 {

   966     TI_UINT32   i;

   967     

   968     *pBitMap = 0;

   969     

   970     for (i = 0; i < len; i++)

   971     {

   972         switch (string[i])

   973         {

   974             case NET_RATE_1M_BASIC:

   975                 *pBitMap |= DRV_RATE_MASK_1_BARKER;

   976                 break;

   977 

   978             case NET_RATE_2M_BASIC:

   979                 *pBitMap |= DRV_RATE_MASK_2_BARKER;

   980                 break;

   981 

   982             case NET_RATE_5_5M_BASIC:

   983                 *pBitMap |= DRV_RATE_MASK_5_5_CCK;

   984                 break;

   985 

   986             case NET_RATE_11M_BASIC:

   987                 *pBitMap |= DRV_RATE_MASK_11_CCK;

   988                 break;

   989 

   990             case NET_RATE_22M_BASIC:

   991                 *pBitMap |= DRV_RATE_MASK_22_PBCC;

   992                 break;

   993 

   994             case NET_RATE_6M_BASIC:

   995                 *pBitMap |= DRV_RATE_MASK_6_OFDM;

   996                 break;

   997 

   998             case NET_RATE_9M_BASIC:

   999                 *pBitMap |= DRV_RATE_MASK_9_OFDM;

  1000                 break;

  1001 

  1002             case NET_RATE_12M_BASIC:

  1003                 *pBitMap |= DRV_RATE_MASK_12_OFDM;

  1004                 break;

  1005 

  1006             case NET_RATE_18M_BASIC:

  1007                 *pBitMap |= DRV_RATE_MASK_18_OFDM;

  1008                 break;

  1009 

  1010             case NET_RATE_24M_BASIC:

  1011                 *pBitMap |= DRV_RATE_MASK_24_OFDM;

  1012                 break;

  1013 

  1014             case NET_RATE_36M_BASIC:

  1015                 *pBitMap |= DRV_RATE_MASK_36_OFDM;

  1016                 break;

  1017 

  1018             case NET_RATE_48M_BASIC:

  1019                 *pBitMap |= DRV_RATE_MASK_48_OFDM;

  1020                 break;

  1021 

  1022             case NET_RATE_54M_BASIC:

  1023                 *pBitMap |= DRV_RATE_MASK_54_OFDM;

  1024                 break;

  1025 

  1026             case NET_RATE_MCS0_BASIC:

  1027                 *pBitMap |= DRV_RATE_MASK_MCS_0_OFDM;

  1028                 break;

  1029     

  1030             case NET_RATE_MCS1_BASIC:

  1031                 *pBitMap |= DRV_RATE_MASK_MCS_1_OFDM;

  1032                 break;

  1033     

  1034             case NET_RATE_MCS2_BASIC:

  1035                 *pBitMap |= DRV_RATE_MASK_MCS_2_OFDM;

  1036                 break;

  1037     

  1038             case NET_RATE_MCS3_BASIC:

  1039                 *pBitMap |= DRV_RATE_MASK_MCS_3_OFDM;

  1040                 break;

  1041     

  1042             case NET_RATE_MCS4_BASIC:

  1043                 *pBitMap |= DRV_RATE_MASK_MCS_4_OFDM;

  1044                 break;

  1045     

  1046             case NET_RATE_MCS5_BASIC:

  1047                 *pBitMap |= DRV_RATE_MASK_MCS_5_OFDM;

  1048                 break;

  1049     

  1050             case NET_RATE_MCS6_BASIC:

  1051                 *pBitMap |= DRV_RATE_MASK_MCS_6_OFDM;

  1052                 break;

  1053     

  1054             case NET_RATE_MCS7_BASIC:

  1055                 *pBitMap |= DRV_RATE_MASK_MCS_7_OFDM;

  1056                 break;

  1057     

  1058             default:

  1059                 break;

  1060         }

  1061     }

  1062 

  1063     return TI_OK;

  1064 }

  1065 

  1066 

  1067 /************************************************************************

  1068  *                        rate_McsNetStrToDrvBitmap                     *

  1069  ************************************************************************

  1070 DESCRIPTION: Converts MCS IEs rates bit map to driver bit map. 

  1071              supported only MCS0 - MCS7 

  1072                                                                                                    

  1073 INPUT:      string - HT capabilities IE in the network format

  1074             len - IE array length

  1075 

  1076 OUTPUT:     bitMap - bit map of rates.

  1077 

  1078 RETURN:     None

  1079 

  1080 ************************************************************************/

  1081 TI_STATUS rate_McsNetStrToDrvBitmap (TI_UINT32 *pBitMap, TI_UINT8 *string)

  1082 {

  1083     *pBitMap = string[0];

  1084 

  1085     *pBitMap = *pBitMap << (DRV_RATE_MCS_0 - 1);

  1086 

  1087     return TI_OK;

  1088 }

  1089 

  1090 

  1091 TI_STATUS rate_DrvBitmapToHwBitmap (TI_UINT32 uDrvBitMap, TI_UINT32 *pHwBitmap)

  1092 {

  1093     TI_UINT32   uHwBitMap = 0;

  1094     

  1095     if (uDrvBitMap & DRV_RATE_MASK_1_BARKER)

  1096     {

  1097         uHwBitMap |= HW_BIT_RATE_1MBPS;

  1098     }

  1099 

  1100     if (uDrvBitMap & DRV_RATE_MASK_2_BARKER)

  1101     {

  1102         uHwBitMap |= HW_BIT_RATE_2MBPS;

  1103     }

  1104 

  1105     if (uDrvBitMap & DRV_RATE_MASK_5_5_CCK)

  1106     {

  1107         uHwBitMap |= HW_BIT_RATE_5_5MBPS;

  1108     }

  1109 

  1110     if (uDrvBitMap & DRV_RATE_MASK_11_CCK)

  1111     {

  1112         uHwBitMap |= HW_BIT_RATE_11MBPS;

  1113     }

  1114 

  1115     if (uDrvBitMap & DRV_RATE_MASK_22_PBCC)

  1116     {

  1117         uHwBitMap |= HW_BIT_RATE_22MBPS;

  1118     }

  1119 

  1120     if (uDrvBitMap & DRV_RATE_MASK_6_OFDM)

  1121     {

  1122         uHwBitMap |= HW_BIT_RATE_6MBPS;

  1123     }

  1124 

  1125     if (uDrvBitMap & DRV_RATE_MASK_9_OFDM)

  1126     {

  1127         uHwBitMap |= HW_BIT_RATE_9MBPS;

  1128     }

  1129 

  1130     if (uDrvBitMap & DRV_RATE_MASK_12_OFDM)

  1131     {

  1132         uHwBitMap |= HW_BIT_RATE_12MBPS;

  1133     }

  1134 

  1135     if (uDrvBitMap & DRV_RATE_MASK_18_OFDM)