开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
misc_wifi.cpp
资源名称：Maui_META_src_v5.0808.0.zip　[点击查看]
上传用户：gelin96
上传日期：2017-01-08
资源大小：20993k
文件大小：30k
源码类别：

MTK

开发平台：

C++ Builder

misc_wifi.cpp：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2001
  8. *
  9. *****************************************************************************/
  11. /*****************************************************************************
  12.  *
  13.  * Filename:
  14.  * ---------
  15.  *   misc_wifi.cpp
  16.  *
  17.  * Project:
  18.  * --------
  19.  *   Maui META APP
  20.  *
  21.  * Description:
  22.  * ------------
  23.  *  WiFi Misc. function source
  24.  *
  25.  * Author:
  26.  * -------
  27.  *  Andy Ueng (mtk00490)
  28.  *
  29.  *============================================================================
  30.  *             HISTORY
  31.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  32.  *------------------------------------------------------------------------------
  33.  * $Revision$
  34.  * $Modtime$
  35.  * $Log$
  36.  * 
  37.  *------------------------------------------------------------------------------
  38.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  39.  *============================================================================
  40.  ****************************************************************************/
  41. #include <vcl.h>
  42. #include <math.h>
  43.  
  44. #pragma hdrstop
  46. #ifndef META_DLL_H
  47. #include "meta.h"
  48. #endif
  50. #ifndef  _MAN_ERROR_H_
  51. #include "man_error.h"
  52. #endif
  54. #ifndef  _FT_UTILS_H_
  55. #include "ft_utils.h"
  56. #endif
  58. #ifndef  _WIFI_COMMON_H_
  59. #include "wifi_common.h"
  60. #endif
  62. //============================================================================
  63. double d_WIFI_802_11B_TX_RATE[] =
  64. {
  65.     1,
  66.     2,
  67.     5.5,
  68.    11
  69. };
  71. double d_WIFI_802_11AG_TX_RATE[] =
  72. {
  73.     6,
  74.     9,
  75.    12,
  76.    18,
  77.    24,
  78.    36,
  79.    48,
  80.    54
  81. };
  83. //==============================================================================
  84. //////////////////////////////        WiFi        //////////////////////////////
  85. //==============================================================================
  86. bool  AnsiString_To_MACAddress( AnsiString ansi_str, WiFi_MacAddress_S &out_value)
  87. {
  88.    /* check if each char is valid */
  89.    {  int   i;
  90.       char  ch;
  91.       char  str[256];
  92.       int   str_len = ansi_str.Length();
  93.       if(str_len==0)  return(false);
  94.       strcpy( str, ansi_str.c_str() );
  96.       for( i=0; i<str_len; i++ )
  97.       {  ch = str[i];
  98.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  99.          break;
  100.       }
  101.       if( i!=str_len )
  102.          return(false);
  103.    }
  104.    /* convert string to integer */
  105.    double d_out_value = atof(ansi_str.c_str());
  106.    if( d_out_value >= pow(2.0, 48) )  return false;
  107.    for( int i=0; i<sizeof(out_value.mac_addr)/sizeof(out_value.mac_addr[0]); i++ )
  108.    {
  109.        out_value.mac_addr[i] = ansi_str.SubString(i+1,1).ToInt();
  110.    }
  112.    return true;
  113. }
  115. //---------------------------------------------------------------------------
  116. bool AnsiString_Hex_To_MACAddress(AnsiString ansi_str, WiFi_MacAddress_S &out_value)
  117. {
  118.     char  str[256];
  119.     long  val;
  120.     int   i;
  121.     /* check if each char is valid */
  123.     char  ch;
  124.     int   str_len = ansi_str.Length();
  125.     if(str_len==0)  return(false);
  126.     strcpy( str, ansi_str.c_str() );
  128.     for( i=0; i<str_len; i++ )
  129.     {
  130.         val = 0;
  131.         ch = str[i];
  132.         if( (ch>='0')&&(ch<='9') )
  133.         {  //val <<= 4;
  134.            val += ch-'0';
  135.         }
  136.         else if( (ch>='A')&&(ch<='F') )
  137.         {  //val <<= 4;
  138.            val += ch-'A'+10;
  139.         }
  140.         else if( (ch>='a')&&(ch<='f') )
  141.         {  //val <<= 4;
  142.            val += ch-'a'+10;
  143.         }
  144.         else if( ch==' ' )
  145.         {
  146.         }
  147.         else
  148.         {  break;
  149.         }
  150.         out_value.mac_addr[i] = val;
  151.         continue;
  152.     }
  154.     if( i!=str_len )
  155.         return(false);
  158.     for( ; i<sizeof(out_value.mac_addr)/sizeof(out_value.mac_addr[0]); i++ )
  159.     {
  160.          out_value.mac_addr[i] = 0;
  161.     }
  163.     return true;
  164. }
  166. //----------------------------------------------------------------------------
  167. bool IsValidDecWiFiBBChipID(AnsiString ansi_str, unsigned short &chip_id)
  168. {
  169.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedShort(ansi_str, chip_id, 0, 65535), RANGE_ERR_WIFI_BB_CHIP_ID);
  171.     return true;
  172. }
  174. //----------------------------------------------------------------------------
  175. bool IsValidHexWiFiBBChipID(AnsiString ansi_str, unsigned short &chip_id)
  176. {
  177.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedShort( ansi_str, chip_id ) , RANGE_ERR_WIFI_BB_CHIP_ID );
  178.     
  179.     return true;
  180. }
  182. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  183. bool IsValidDecWiFiRFChipID(AnsiString ansi_str, unsigned short &chip_id)
  184. {
  185.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedShort(ansi_str, chip_id, 0, 65535), RANGE_ERR_WIFI_RF_CHIP_ID);
  187.     return true;
  188. }
  190. //----------------------------------------------------------------------------
  191. bool IsValidHexWiFiRFChipID(AnsiString ansi_str, unsigned short &chip_id)
  192. {
  193.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedShort(ansi_str, chip_id), RANGE_ERR_WIFI_RF_CHIP_ID);
  195.     return true;
  196. }
  198. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  199. bool IsValidDecWiFiSN(AnsiString ansi_str, unsigned int &sn)
  200. {
  201.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, sn, 0, 4294967295), RANGE_ERR_WIFI_SN);
  203.     return true;
  204. }
  206. //----------------------------------------------------------------------------
  207. bool IsValidHexWiFiSN(AnsiString ansi_str, unsigned int &sn)
  208. {
  209.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedInt(ansi_str, sn), RANGE_ERR_WIFI_SN);
  211.     return true;
  212. }
  214. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  215. bool IsValidDecWiFiMACAddress(AnsiString ansi_str, unsigned char &mac_addr_char)
  216. {
  217.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, mac_addr_char, 0, 255), RANGE_ERR_WIFI_MAC_ADDRESS);
  219.     return true;
  220. }
  222. //----------------------------------------------------------------------------
  223. bool IsValidHexWiFiMACAddress(AnsiString ansi_str, unsigned char &mac_addr_char)
  224. {
  225.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, mac_addr_char, 0, 255), RANGE_ERR_WIFI_MAC_ADDRESS);
  227.     return true;
  228. }
  230. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  231. bool IsValidDecWiFiBBRegAddr(AnsiString ansi_str, unsigned int &addr)
  232. {
  233.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, addr, 0, 4294967295), RANGE_ERR_WIFI_BB_REG_ADDR);
  235.     return  true;
  236. }
  238. //---------------------------------------------------------------------------
  239. bool IsValidHexWiFiBBRegAddr(AnsiString ansi_str, unsigned char &addr)
  240. {
  241.    RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, addr, 0, 255), RANGE_ERR_WIFI_BB_REG_ADDR);
  243.    return  true;
  244. }
  246. //---------------------------------------------------------------------------
  247. bool IsValidDecWiFiBBRegValue(AnsiString ansi_str, unsigned char &value)
  248. {
  249.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, value, 0, 255) , RANGE_ERR_WIFI_BB_REG_VALUE);
  251.     return true;
  252. }
  254. //---------------------------------------------------------------------------
  255. bool IsValidHexWiFiBBRegValue(AnsiString ansi_str, unsigned char &value)
  256. {
  257.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, value, 0, 255), RANGE_ERR_WIFI_BB_REG_VALUE);
  259.     return true;
  260. }
  262. //--------------------------------------------------------------------------
  263. bool IsValidHexWiFiMacRegAddr(AnsiString ansi_str, unsigned int &addr)
  264. {
  265.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedInt(ansi_str, addr ), RANGE_ERR_WIFI_MAC_REG_ADDR);
  267.     return  true;
  268. }
  270. //---------------------------------------------------------------------------
  271. bool IsValidDecWiFiMacRegValue(AnsiString ansi_str, unsigned int &value)
  272. {
  273.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, value, 0, 4294967295), RANGE_ERR_WIFI_MAC_REG_VALUE);
  275.     return true;
  276. }
  278. //---------------------------------------------------------------------------
  279. bool IsValidHexWiFiMacRegValue(AnsiString ansi_str, unsigned int &value)
  280. {
  281.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedInt(ansi_str, value), RANGE_ERR_WIFI_MAC_REG_VALUE);
  283.     return true;
  284. }
  286. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  287. bool IsValidDecWiFiMacReg16Value(AnsiString ansi_str, unsigned short &value)
  288. {
  289.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedShort(ansi_str, value, 0, 65536), RANGE_ERR_WIFI_MAC_REG_VALUE);
  291.     return true;
  292. }
  294. //---------------------------------------------------------------------------
  295. bool IsValidHexWiFiMacReg16Value(AnsiString ansi_str, unsigned short &value)
  296. {
  297.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedShort(ansi_str, value), RANGE_ERR_WIFI_MAC_REG_VALUE);
  299.     return true;
  300. }
  302. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  303. bool IsValidHexWiFiEERegAddr(AnsiString ansi_str, unsigned int &addr)
  304. {
  305.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedInt(ansi_str, addr), RANGE_ERR_WIFI_EE_ADDR);
  307.     return  true;
  308. }
  310. //---------------------------------------------------------------------------
  311. bool IsValidDecWiFiEERegValue(AnsiString ansi_str, unsigned short &value)
  312. {
  313.     RANGE_CHECK_ERROR( !AnsiString_To_UnsignedShort(ansi_str, value, 0, 65535), RANGE_ERR_WIFI_EE_VALUE);
  315.     return true;
  316. }
  318. //---------------------------------------------------------------------------
  319. bool IsValidHexWiFiEERegValue(AnsiString ansi_str, unsigned short &value)
  320. {
  321.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedShort(ansi_str, value), RANGE_ERR_WIFI_EE_VALUE);
  323.     return true;
  324. }
  326. //----------------------------------------------------------------------------
  327. bool IsValidWiFiPacketLength(AnsiString ansi_str, unsigned int &pkt_length)
  328. {
  329.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, pkt_length, 0, 6000), RANGE_ERR_WIFI_PACKET_LENGTH);
  331.     return true;
  332. }
  334. //----------------------------------------------------------------------------
  335. bool IsValidWiFiPacketCount(AnsiString ansi_str, unsigned int &pkt_count)
  336. {
  337.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, pkt_count, 0, 4294967295), RANGE_ERR_WIFI_PACKET_COUNT);
  339.     return true;
  340. }
  342. //----------------------------------------------------------------------------
  343. bool IsValidWiFiPacketInterval(AnsiString ansi_str, unsigned int &pkt_interval)
  344. {
  345.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, pkt_interval, 0, 4294967295), RANGE_ERR_WIFI_PACKET_INTERVAL);
  347.     return true;
  348. }
  350. //----------------------------------------------------------------------------
  351. bool IsValidDecWiFiTxPowerDac(AnsiString ansi_str, unsigned char &dac)
  352. {
  353.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, dac, 0, 63), RANGE_ERR_WIFI_TX_POWER_DAC);
  355.     return true;
  356. }
  358. //----------------------------------------------------------------------------
  359. bool IsValidHexWiFiTxPowerDac(AnsiString ansi_str, unsigned char &dac)
  360. {
  361.     RANGE_CHECK_ERROR( !AnsiString_Hex_To_UnsignedChar(ansi_str, dac, 0, 63), RANGE_ERR_WIFI_TX_POWER_DAC);
  363.     return true;
  364. }
  366. //----------------------------------------------------------------------------
  367. bool IsValidDecWiFiTxDcOffset(AnsiString ansi_str, unsigned char &txdc)
  368. {
  369.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, txdc, 0, 255), RANGE_ERR_WIFI_TX_DC_OFFSET);
  371.     return true;
  372. }
  374. //----------------------------------------------------------------------------
  375. bool IsValidHexWiFiTxDcOffset(AnsiString ansi_str, unsigned char &txdc)
  376. {
  377.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, txdc, 0, 255), RANGE_ERR_WIFI_TX_DC_OFFSET);
  379.     return true;
  380. }
  382. //----------------------------------------------------------------------------
  383. bool IsValidHexWiFiMacHeaderFrameCtrl(AnsiString ansi_str, unsigned char &frame_ctrl)
  384. {
  385.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, frame_ctrl, 0, 255), RANGE_ERR_WIFI_MAC_HEADER_FRAME_CTRL);
  387.     return true;
  388. }
  390. //----------------------------------------------------------------------------
  391. bool IsValidHexWiFiMacHeaderDuration(AnsiString ansi_str, unsigned char &duration)
  392. {
  393.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, duration, 0, 255), RANGE_ERR_WIFI_MAC_HEADER_DURATION);
  395.     return true;
  396. }
  398. //----------------------------------------------------------------------------
  399. bool IsValidHexWiFiMacHeaderAddress(AnsiString ansi_str, unsigned char &addr)
  400. {
  401.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, addr, 0, 255), RANGE_ERR_WIFI_MAC_HEADER_ADDRESS);
  403.     return true;
  404. }
  406. //----------------------------------------------------------------------------
  407. bool IsValidHexWiFiMacHeaderSeqCtrl(AnsiString ansi_str, unsigned char &seq_ctrl)
  408. {
  409.     RANGE_CHECK_ERROR(!AnsiString_Hex_To_UnsignedChar(ansi_str, seq_ctrl, 0, 255), RANGE_ERR_WIFI_MAC_HEADER_SEQ_CTRL);
  411.     return true;
  412. }
  414. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  415. // ALC
  416. bool IsValidWiFiTxAlcCCK(AnsiString ansi_str, unsigned char &tx_alc)
  417. {
  418.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, tx_alc, 0, 255), RANGE_ERR_WIFI_TX_ALC_CCK);
  420.     return true;
  421. }
  423. //----------------------------------------------------------------------------
  424. bool IsValidWiFiTxOutputPowerDbCCK(AnsiString ansi_str, unsigned char &output_power)
  425. {
  426.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, output_power, 0, 255), RANGE_ERR_WIFI_TX_OUTPUT_POWER_DB_CCK);
  428.     return true;
  429. }
  431. //---------------------------------------------------------------------------
  432. bool IsValidWiFiTxAlcOFDM(AnsiString ansi_str, unsigned char &tx_alc)
  433. {
  434.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, tx_alc, 0, 255), RANGE_ERR_WIFI_TX_ALC_OFDM);
  436.     return true;
  437. }
  439. //----------------------------------------------------------------------------
  440. bool IsValidWiFiTxOutputPowerDbOFDM(AnsiString ansi_str, unsigned char &output_power)
  441. {
  442.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, output_power, 0, 255), RANGE_ERR_WIFI_TX_OUTPUT_POWER_DB_OFDM);
  444.     return true;
  445. }
  447. //---------------------------------------------------------------------------
  448. bool IsValidWiFiAlcOffset(AnsiString ansi_str, char &offset)
  449. {
  450.     RANGE_CHECK_ERROR(!AnsiString_To_char(ansi_str, offset, -128, 127), RANGE_ERR_WIFI_ALC_OFFSET);
  452.     return true;
  453. }
  455. //---------------------------------------------------------------------------
  456. bool IsValidWiFiTargetALC(AnsiString ansi_str, unsigned int &alc)
  457. {
  458.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedInteger(ansi_str, alc, 0, 255), RANGE_ERR_WIFI_TARGET_ALC);
  460.     return true;
  461. }
  463. //---------------------------------------------------------------------------
  464. bool IsValidWiFiAlcSlopeDivider(AnsiString ansi_str, unsigned char &alc_slope_divider)
  465. {
  466.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, alc_slope_divider, 1, 100), RANGE_ERR_WIFI_ALC_SLOPE_DIVIDER);
  468.     return true;
  469. }
  471. //---------------------------------------------------------------------------
  472. bool IsValidWiFiAlcSlopeDividend(AnsiString ansi_str, unsigned char &alc_slope_dividend)
  473. {
  474.     RANGE_CHECK_ERROR(!AnsiString_To_UnsignedChar(ansi_str, alc_slope_dividend, 1, 100), RANGE_ERR_WIFI_ALC_SLOPE_DIVIDEND);
  476.     return true;
  477. }
  479. //===========================================================================
  480. //////////////////////////////  Format transform   //////////////////////////
  481. //===========================================================================
  482. bool MACAddress_To_Str(WiFi_MacAddress_S mac_addr, AnsiString &as_str)
  483. {
  484.     as_str = "";
  485.     int mac_addr_size = sizeof(mac_addr.mac_addr)/sizeof(mac_addr.mac_addr[0]);
  486.     for( int i=0; i<mac_addr_size; i++ )
  487.     {
  488.         if( i != mac_addr_size-1 )
  489.         {
  490.             as_str += IntToStr( mac_addr.mac_addr[mac_addr_size-i-1] )+":";
  491.         }
  492.         else
  493.         {
  494.             as_str += IntToStr( mac_addr.mac_addr[mac_addr_size-i-1] );
  495.         }
  496.     }
  498.     return true;
  499. }
  501. //---------------------------------------------------------------------------
  502. bool Str_To_MACAddress(AnsiString as_str, WiFi_MacAddress_S &mac_addr)
  503. {
  504.     char str[256];
  505.     WiFi_MacAddress_S temp_mac_addr;
  507.     strcpy( str, as_str.c_str() );
  508.     int mac_address_len = sizeof(mac_addr.mac_addr)/sizeof(mac_addr.mac_addr[0]);
  510.     String_To_Array_UnsignedChar( str, temp_mac_addr.mac_addr, mac_address_len );
  512.     for( int i=0; i<mac_address_len; i++ )
  513.     {
  514.         mac_addr.mac_addr[i] = temp_mac_addr.mac_addr[mac_address_len-i-1];
  515.     }
  517.     return true;
  518. }
  520. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  521. unsigned int GetWiFiChannelFreqFromStr(AnsiString as_str)
  522. {
  523.     unsigned int ch_freq;
  525.     int begin_pos, end_pos;
  526.     begin_pos = as_str.AnsiPos( "(" ) + 1;
  527.     end_pos   = as_str.AnsiPos( ")" ) - 1;
  528.     as_str = as_str.SubString( begin_pos, end_pos - begin_pos + 1 );
  529.     ch_freq = as_str.ToInt();
  531.     return ch_freq;
  532. }
  534. const unsigned int WIFI_802_11BG_CHANNEL_FREQ_KHZ[] =
  535. {
  536.     2412000,
  537.     2417000,
  538.     2422000,
  539.     2427000,
  540.     2432000,
  541.     2437000,
  542.     2442000,
  543.     2447000,
  544.     2452000,
  545.     2457000,
  546.     2462000,
  547.     2467000,
  548.     2472000,
  549.     2484000
  550. };
  552. const unsigned int WIFI_802_11A_CHANNEL_FREQ_KHZ[] =
  553. {
  554.     5040000,
  555.     5060000,
  556.     5080000,
  557.     5170000,
  558.     5180000,
  559.     5190000,
  560.     5200000,
  561.     5210000,
  562.     5220000,
  563.     5230000,
  564.     5240000,
  565.     5260000,
  566.     5280000,
  567.     5300000,
  568.     5320000,
  569.     5500000,
  570.     5520000,
  571.     5540000,
  572.     5560000,
  573.     5580000,
  574.     5600000,
  575.     5620000,
  576.     5640000,
  577.     5660000,
  578.     5680000,
  579.     5700000,
  580.     5745000,
  581.     5765000,
  582.     5785000,
  583.     5805000,
  584.     4920000,
  585.     4940000,
  586.     4960000,
  587.     4980000
  588. };
  590. //---------------------------------------------------------------------------
  591. unsigned int GetWiFiChannelFrequency(E_WIFI_GENERATION _802_11_type, int idx)
  592. {
  593.     unsigned int freq;
  594.     if( WIFI_802_11A_IDX != _802_11_type ) // 802.11b, 802.11g
  595.     {
  596.         freq = WIFI_802_11BG_CHANNEL_FREQ_KHZ[idx];
  597.     }
  598.     else
  599.     {
  600.         freq = WIFI_802_11A_CHANNEL_FREQ_KHZ[idx];
  601.     }
  602.     return freq;
  603. }
  604. //---------------------------------------------------------------------------
  605. bool GetWiFiChannelIndexFromStr(AnsiString as_channel, AnsiString as_txrate, E_WIFI_GENERATION &wifi_802_11_idx, unsigned int &chan_idx)
  606. {
  607.     AnsiString asWIFI_802_11B_TX_RATE_MHZ[] =
  608.     {
  609.         "1",
  610.         "2",
  611.         "5.5",
  612.         "11"
  613.     };
  615.     unsigned int chan_freq = GetWiFiChannelFreqFromStr( as_channel );
  616.     int i, j;
  618.     for( i=0; i<sizeof(WIFI_802_11BG_CHANNEL_FREQ_KHZ)/sizeof(WIFI_802_11BG_CHANNEL_FREQ_KHZ[0]); i++ )
  619.     {
  620.         if( chan_freq == WIFI_802_11BG_CHANNEL_FREQ_KHZ[i] )
  621.         {
  622.             chan_idx = i;
  623.             for (j=0; j<4; j++)
  624.             {
  625.                 if( as_txrate.AnsiCompareIC(asWIFI_802_11B_TX_RATE_MHZ[j]) == 0 )
  626.                 {
  627.                     wifi_802_11_idx = WIFI_802_11B_IDX;
  628.                     return true;
  629.                 }
  630.             }
  631.             wifi_802_11_idx = WIFI_802_11G_IDX;
  632.             return true;
  633.         }
  634.     }
  636.     for( i=0; i<sizeof(WIFI_802_11A_CHANNEL_FREQ_KHZ)/sizeof(WIFI_802_11A_CHANNEL_FREQ_KHZ[0]); j++ )
  637.     {
  638.         if( chan_freq == WIFI_802_11A_CHANNEL_FREQ_KHZ[i] )
  639.         {
  640.             chan_idx = i;
  641.             wifi_802_11_idx = WIFI_802_11A_IDX;
  642.             return true;
  643.         }
  644.     }
  646.     return false;
  647. }
  649. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  650. static AnsiString asWIFI_802_11ABG_TX_RATE_MHZ[] =
  651. {
  652.     "1",
  653.     "2",
  654.     "5.5",
  655.     "11",
  656.     "6",
  657.     "9",
  658.     "12",
  659.     "18",
  660.     "24",
  661.     "36",
  662.     "48",
  663.     "54"
  664. };
  666. //---------------------------------------------------------------------------
  667. unsigned int GetWiFiTxRateFromStr(AnsiString as_str)
  668. {
  669.     unsigned int tx_rate=0;
  671.     for( int i=0; i<WIFI_OFDM_TX_RATE_NUM; i++ )
  672.     {
  673.         if( as_str.AnsiCompareIC(asWIFI_802_11ABG_TX_RATE_MHZ[i]) == 0 )
  674.         {
  675.             tx_rate = i;
  676.             break;
  677.         }
  678.     }
  680.     return tx_rate;
  681. }
  683. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  684. bool IsValidWiFiTxRate(E_WIFI_GENERATION wifi_gen, double d_tx_rate)
  685. {
  686.     bool match = false;
  687.     switch (wifi_gen)
  688.     {
  689.         case WIFI_802_11A_IDX:
  690.         case WIFI_802_11G_IDX:
  691.         {
  692.             for (int i=0; i<sizeof(d_WIFI_802_11AG_TX_RATE)/sizeof(d_WIFI_802_11AG_TX_RATE[0]); i++)
  693.             {
  694.                 if (d_tx_rate == d_WIFI_802_11AG_TX_RATE[i])
  695.                 {
  696.                     match = true;
  697.                 }
  698.             }
  699.         }
  700.         break;
  702.         case WIFI_802_11B_IDX:
  703.         {
  704.             for (int i=0; i<sizeof(d_WIFI_802_11B_TX_RATE)/sizeof(d_WIFI_802_11B_TX_RATE[0]); i++)
  705.             {
  706.                 if (d_tx_rate == d_WIFI_802_11B_TX_RATE[i])
  707.                 {
  708.                     match = true;
  709.                 }
  710.             }
  711.         }
  712.         break;
  714.         default:
  715.         {
  716.             return false;
  717.         }
  718.     }
  720.     return match;
  721. }
  723. //===========================================================================
  724. bool IsWiFiSupported(AnsiString as_802_11, E_WIFI_GENERATION e_802_11_idx)
  725. {
  726.     int i = as_802_11.ToInt();
  727.     bool b_support;
  728.     switch (e_802_11_idx)
  729.     {
  730.         case WIFI_802_11A_IDX:
  731.         {
  732.             if (i & 0x01)
  733.             {
  734.                b_support = true;
  735.             }
  736.             else
  737.             {
  738.                b_support = false;
  739.             }
  740.         }
  741.         break;
  743. case WIFI_802_11B_IDX:
  744.         {
  745.             if (i & 0x02)
  746.             {
  747.                b_support = true;
  748.             }
  749.             else
  750.             {
  751.                b_support = false;
  752.             }
  753.         }
  754.         break;
  756. case WIFI_802_11G_IDX:
  757.         {
  758.             if (i & 0x04)
  759.             {
  760.                b_support = true;
  761.             }
  762.             else
  763.             {
  764.                b_support = false;
  765.             }
  766.         }
  767.         break;
  769.         default:
  770.         {
  771.             b_support = false;
  772.         }
  773.         break;
  774.     } // switch
  775.     return b_support;
  776. }
  778. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  779. bool GetWiFiTxRate(double d_tx_rate_mhz, WiFi_TestRate_E &e_tx_rate)
  780. {
  781.     if (1 == d_tx_rate_mhz)
  782.     {
  783.         e_tx_rate = WIFI_TEST_RATE_1M;
  784.     }
  785.     else if (2 == d_tx_rate_mhz)
  786.     {
  787.         e_tx_rate = WIFI_TEST_RATE_2M;
  788.     }
  789.     else if (5.5 == d_tx_rate_mhz)
  790.     {
  791.         e_tx_rate = WIFI_TEST_RATE_5_5M;
  792.     }
  793.     else if (11 == d_tx_rate_mhz)
  794.     {
  795.         e_tx_rate = WIFI_TEST_RATE_11M;
  796.     }
  797.     else if (6 == d_tx_rate_mhz)
  798.     {
  799.         e_tx_rate = WIFI_TEST_RATE_6M;
  800.     }
  801.     else if (9 == d_tx_rate_mhz)
  802.     {
  803.         e_tx_rate = WIFI_TEST_RATE_9M;
  804.     }
  805.     else if (12 == d_tx_rate_mhz)
  806.     {
  807.         e_tx_rate = WIFI_TEST_RATE_12M;
  808.     }
  809.     else if (18 == d_tx_rate_mhz)
  810.     {
  811.         e_tx_rate = WIFI_TEST_RATE_18M;
  812.     }
  813.     else if (24 == d_tx_rate_mhz)
  814.     {
  815.         e_tx_rate = WIFI_TEST_RATE_24M;
  816.     }
  817.     else if (36 == d_tx_rate_mhz)
  818.     {
  819.         e_tx_rate = WIFI_TEST_RATE_36M;
  820.     }
  821.     else if (48 == d_tx_rate_mhz)
  822.     {
  823.         e_tx_rate = WIFI_TEST_RATE_48M;
  824.     }
  825.     else if (54 == d_tx_rate_mhz)
  826.     {
  827.         e_tx_rate = WIFI_TEST_RATE_54M;
  828.     }
  829.     else
  830.     {
  831.         return false;
  832.     }
  834.     return true;
  835. }
  837. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  838. int GetWiFiRemainChannels(E_WIFI_GENERATION wifi_gen, S_WIFI_CH_FREQ_MHZ org_ch_freq_mhz, S_WIFI_CH_FREQ_MHZ &remain_ch_freq_mhz)
  839. {
  840.     int ch_num = 0;
  841.     bool match;
  843.     switch (wifi_gen)
  844.     {
  845.         case WIFI_802_11A_IDX:
  846.         {
  847.             for (int i=0; i<sizeof(WIFI_802_11A_CHANNEL_FREQ_KHZ)/sizeof(WIFI_802_11A_CHANNEL_FREQ_KHZ[0]); i++)
  848.             {
  849.                 for (int j=0; j<org_ch_freq_mhz.ch_num; j++)
  850.                 {
  851.                     match = false;
  853.                     if ((org_ch_freq_mhz.ch_freq_MHz[j]*1000) == WIFI_802_11A_CHANNEL_FREQ_KHZ[i])
  854.                     {
  855.                         match = true;
  856.                         break;
  857.                     }
  858.                 }
  860.                 if (!match)
  861.                 {
  862.                     remain_ch_freq_mhz.ch_freq_MHz[ch_num] = WIFI_802_11A_CHANNEL_FREQ_KHZ[i]/1000;
  863.                     ch_num++;
  864.                 }
  865.             }
  866.         }
  867.         break;
  869.         case WIFI_802_11B_IDX:
  870.         case WIFI_802_11G_IDX:
  871.         {
  872.             for (int i=0; i<sizeof(WIFI_802_11BG_CHANNEL_FREQ_KHZ)/sizeof(WIFI_802_11BG_CHANNEL_FREQ_KHZ[0]); i++)
  873.             {
  874.                 for (int j=0; j<org_ch_freq_mhz.ch_num; j++)
  875.                 {
  876.                     match = false;
  878.                     if ((org_ch_freq_mhz.ch_freq_MHz[j]*1000) == WIFI_802_11BG_CHANNEL_FREQ_KHZ[i])
  879.                     {
  880.                         match = true;
  881.                         break;
  882.                     }
  883.                 }
  885.                 if (!match)
  886.                 {
  887.                     remain_ch_freq_mhz.ch_freq_MHz[ch_num] = WIFI_802_11BG_CHANNEL_FREQ_KHZ[i]/1000;
  888.                     ch_num++;
  889.                 }
  890.             }
  891.         }
  892.         break;
  894.         default:
  895.         {
  896.             ch_num = 0;
  897.         }
  898.         break;
  899.     }
  901.     return ch_num;
  902. }
  904. //--------------------------------------------------------------------------
  905. int GetWiFiNVRAMChannelIndex(E_WIFI_GENERATION wifi_gen, unsigned int ch_freq_mhz)
  906. {
  907.     int nvram_ch_index = -1;
  908.     unsigned int ch_freq_kHz = ch_freq_mhz * 1000;
  909.     switch (wifi_gen)
  910.     {
  911.         case WIFI_802_11A_IDX:
  912.         {
  913.             for (int j=0; j<sizeof(WIFI_802_11A_CHANNEL_FREQ_KHZ)/sizeof(WIFI_802_11A_CHANNEL_FREQ_KHZ[0]); j++)
  914.             {
  915.                 if (ch_freq_kHz == WIFI_802_11A_CHANNEL_FREQ_KHZ[j])
  916.                 {
  917.                     nvram_ch_index = j;
  918.                     break;
  919.                 }
  920.             }
  921.         }
  922.         break;
  924.         case WIFI_802_11B_IDX:
  925.         case WIFI_802_11G_IDX:
  926.         {
  927.             for (int j=0; j<sizeof(WIFI_802_11BG_CHANNEL_FREQ_KHZ)/sizeof(WIFI_802_11BG_CHANNEL_FREQ_KHZ[0]); j++)
  928.             {
  929.                 if(ch_freq_kHz == WIFI_802_11BG_CHANNEL_FREQ_KHZ[j])
  930.                 {
  931.                     nvram_ch_index = j;
  932.                     break;
  933.                 }
  934.             }
  935.         }
  936.         break;
  938.         default:
  939.         {
  940.             nvram_ch_index = -1;
  941.         }
  942.         break;
  943.     }
  945.     return nvram_ch_index;
  946. }
  948. //----------------------------------------------------------------------------
  949. bool GetWiFiTwoClosetNVRAMChannelIndex(E_WIFI_GENERATION wifi_gen, unsigned int ch_freq_MHz, S_WIFI_CH_FREQ_MHZ s_ch_freq_MHz, int &first_ch_index, int &second_ch_index)
  950. {
  951.     int nvram_ch_index = GetWiFiNVRAMChannelIndex(wifi_gen, ch_freq_MHz);
  952.     bool found_first = false;
  953.     bool found_second = false;
  954.     unsigned int ui_first_ch_MHz;
  955.     unsigned int ui_second_ch_MHz;
  956.     int ch_num;
  957.     int i;
  958.     switch (wifi_gen)
  959.     {
  960.         case WIFI_802_11A_IDX:
  961.         {
  962.             ch_num = NUM_TX_POWER_5000M_CH;
  963.         }
  964.         break;
  966.         case WIFI_802_11B_IDX:
  967.         case WIFI_802_11G_IDX:
  968.         {
  969.             ch_num = NUM_TX_POWER_2400M_CH;
  970.         }
  971.         break;
  973.         default:
  974.         {
  975.             return false;
  976.         }
  977.     }
  979.     if (0 == nvram_ch_index)
  980.     {
  981.         first_ch_index  = GetWiFiNVRAMChannelIndex(wifi_gen, s_ch_freq_MHz.ch_freq_MHz[0]);
  982.         second_ch_index = GetWiFiNVRAMChannelIndex(wifi_gen, s_ch_freq_MHz.ch_freq_MHz[1]);
  983.     }
  984.     else if (ch_num-1 == nvram_ch_index)
  985.     {
  986.         first_ch_index  = GetWiFiNVRAMChannelIndex(wifi_gen, s_ch_freq_MHz.ch_freq_MHz[s_ch_freq_MHz.ch_num-2]);
  987.         second_ch_index = GetWiFiNVRAMChannelIndex(wifi_gen, s_ch_freq_MHz.ch_freq_MHz[s_ch_freq_MHz.ch_num-1]);
  988.     }
  989.     else
  990.     {
  991.         found_first = false;
  992.         for (i=0; i<s_ch_freq_MHz.ch_num; i++)
  993.         {
  994.             if (s_ch_freq_MHz.ch_freq_MHz[i] > ch_freq_MHz)
  995.             {
  996.                 found_first = true;
  997.                 break;
  998.             }
  999.         }
  1001.         if (found_first)
  1002.         {
  1003.             ui_first_ch_MHz = s_ch_freq_MHz.ch_freq_MHz[i];
  1004.             first_ch_index  = GetWiFiNVRAMChannelIndex(wifi_gen, ui_first_ch_MHz);
  1006.             found_second = false;
  1007.             for (i=s_ch_freq_MHz.ch_num-1; i>=0; i--)
  1008.             {
  1009.                 if (s_ch_freq_MHz.ch_freq_MHz[i] < ch_freq_MHz)
  1010.                 {
  1011.                     found_second = true;
  1012.                     break;
  1013.                 }
  1014.             }
  1016.             if (found_second)
  1017.             {
  1018.                 ui_second_ch_MHz = s_ch_freq_MHz.ch_freq_MHz[i];
  1019.                 second_ch_index  = GetWiFiNVRAMChannelIndex(wifi_gen, ui_second_ch_MHz);
  1020.             }
  1021.             else
  1022.             {
  1023.                 for (i=0; i<s_ch_freq_MHz.ch_num; i++)
  1024.                 {
  1025.                     if (s_ch_freq_MHz.ch_freq_MHz[i] > ui_first_ch_MHz)
  1026.                     {
  1027.                         found_second = true;
  1028.                         break;
  1029.                     }
  1030.                 }
  1031.                 ui_second_ch_MHz = s_ch_freq_MHz.ch_freq_MHz[i];
  1032.                 second_ch_index  = GetWiFiNVRAMChannelIndex(wifi_gen, ui_second_ch_MHz);
  1033.             }
  1034.         }
  1035.         else // not found_first
  1036.         {
  1037.             for (i=s_ch_freq_MHz.ch_num-1; i>=0; i--)
  1038.             {
  1039.                 if (s_ch_freq_MHz.ch_freq_MHz[i] < ch_freq_MHz)
  1040.                 {
  1041.                     found_first = true;
  1042.                     break;
  1043.                 }
  1044.             }
  1045.             ui_first_ch_MHz = s_ch_freq_MHz.ch_freq_MHz[i];
  1046.             first_ch_index  = GetWiFiNVRAMChannelIndex(wifi_gen, ui_first_ch_MHz);
  1048.             found_second = false;
  1049.             for (i=s_ch_freq_MHz.ch_num-1; i>=0; i--)
  1050.             {
  1051.                 if (s_ch_freq_MHz.ch_freq_MHz[i] < ui_first_ch_MHz)
  1052.                 {
  1053.                     found_second = true;
  1054.                     break;
  1055.                 }
  1056.             }
  1058.             if (found_second)
  1059.             {
  1060.                 ui_second_ch_MHz = s_ch_freq_MHz.ch_freq_MHz[i];
  1061.                 second_ch_index  = GetWiFiNVRAMChannelIndex(wifi_gen, ui_second_ch_MHz);
  1062.             }
  1063.         }
  1064.     }
  1066.     return (found_first && found_second);
  1067. }