Home | History | Annotate | Download | only in src
      1 /*
      2  * cu_cmd.c
      3  *
      4  * Copyright 2001-2010 Texas Instruments, Inc. - http://www.ti.com/
      5  *
      6  * Licensed under the Apache License, Version 2.0 (the "License");
      7  * you may not use this file except in compliance with the License.
      8  * You may obtain a copy of the License at
      9  *
     10  *     http://www.apache.org/licenses/LICENSE-2.0
     11  *
     12  * Unless required by applicable law or agreed to in writing, software
     13  * distributed under the License is distributed on an "AS IS" BASIS,
     14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     15  * See the License for the specific language governing permissions and
     16  * limitations under the License.
     17  */
     18 
     19 /****************************************************************************
     20 *
     21 *   MODULE:  cu_cmd.c
     22 *
     23 *   PURPOSE:
     24 *
     25 *   DESCRIPTION:
     26 *   ============
     27 *
     28 *
     29 ****************************************************************************/
     30 
     31 /* includes */
     32 /************/
     33 
     34 #include <stdio.h>
     35 
     36 #include "cu_osapi.h"
     37 #include "TWDriver.h"
     38 #include "convert.h"
     39 #include "console.h"
     40 #include "cu_common.h"
     41 #include "cu_os.h"
     42 #include "ipc_event.h"
     43 #include "wpa_core.h"
     44 #include "cu_cmd.h"
     45 #include "oserr.h"
     46 
     47 /* defines */
     48 /***********/
     49 #define print_available_values(arr) \
     50         { \
     51             S32 i; \
     52             for(i=0; i<SIZE_ARR(arr); i++) \
     53                 os_error_printf(CU_MSG_INFO2, (PS8)"%d - %s%s", arr[i].value, arr[i].name, (i>=SIZE_ARR(arr)-1) ? (PS8)"\n" : (PS8)", " ); \
     54         }
     55 
     56 #define CU_CMD_FIND_NAME_ARRAY(index, arr, val) \
     57         for ( index = 0; index < SIZE_ARR(arr); index++ ) \
     58             if ( arr[ index ].value == (val) ) \
     59                 break; \
     60 
     61 #define CHAN_FREQ_TABLE_SIZE        (sizeof(ChanFreq) / sizeof(struct CHAN_FREQ))
     62 
     63 #define IS_BASIC_RATE(a)    ((a) & NET_BASIC_MASK)
     64 
     65 #define RATE_2_MBPS(a)    ((F32)((a) & (NET_BASIC_MASK-1))/2)
     66 
     67 #define NET_BASIC_MASK      0x80    /* defined in common/src/utils/utils.c */
     68 
     69 #define BIT_TO_BYTE_FACTOR  8
     70 
     71 #define NVS_FILE_TX_PARAMETERS_UPDATE	0
     72 #define NVS_FILE_RX_PARAMETERS_UPDATE	1
     73 
     74 
     75 /* local types */
     76 /***************/
     77 /* Module control block */
     78 typedef struct CuCmd_t
     79 {
     80     THandle                 hCuWext;
     81     THandle                 hCuCommon;
     82     THandle                 hConsole;
     83     THandle                 hIpcEvent;
     84     THandle                 hWpaCore;
     85 
     86     U32                     isDeviceRunning;
     87 
     88     scan_Params_t             appScanParams;
     89     TPeriodicScanParams     tPeriodicAppScanParams;
     90     scan_Policy_t             scanPolicy;
     91 
     92 } CuCmd_t;
     93 
     94 /* local variables */
     95 /*******************/
     96 struct CHAN_FREQ {
     97     U8       chan;
     98     U32      freq;
     99 } ChanFreq[] = {
    100     {1,2412000}, {2,2417000}, {3,2422000}, {4,2427000},
    101     {5,2432000}, {6,2437000}, {7,2442000}, {8,2447000},
    102     {9,2452000},
    103     {10,2457000}, {11,2462000}, {12,2467000}, {13,2472000},
    104     {14,2484000}, {36,5180000}, {40,5200000}, {44,5220000},
    105     {48,5240000}, {52,5260000}, {56,5280000}, {60,5300000},
    106     {64,5320000},
    107     {100,5500000}, {104,5520000}, {108,5540000}, {112,5560000},
    108     {116,5580000}, {120,5600000}, {124,5620000}, {128,5640000},
    109     {132,5660000}, {136,5680000}, {140,5700000}, {149,5745000},
    110     {153,5765000}, {157,5785000}, {161,5805000} };
    111 
    112 static named_value_t BSS_type[] =
    113 {
    114     { os802_11IBSS,                  (PS8)"AD-Hoc" },
    115     { os802_11Infrastructure,        (PS8)"Infr." },
    116     { os802_11AutoUnknown,           (PS8)"Auto" },
    117 };
    118 
    119 static named_value_t Current_mode[] =
    120 {
    121     { 0,           (PS8)"SME Auto" },
    122     { 1,           (PS8)"SME Manual" },
    123 };
    124 
    125 static named_value_t BeaconFilter_use[] =
    126 {
    127     { 0,        (PS8)"INACTIVE" },
    128     { 1,        (PS8)"ACTIVE" },
    129 };
    130 
    131 static named_value_t event_type[] = {
    132     { IPC_EVENT_ASSOCIATED,             (PS8)"Associated" },
    133     { IPC_EVENT_DISASSOCIATED,          (PS8)"Disassociated"  },
    134     { IPC_EVENT_LINK_SPEED,             (PS8)"LinkSpeed" },
    135     { IPC_EVENT_AUTH_SUCC,              (PS8)"Authentication Success" },
    136     { IPC_EVENT_SCAN_COMPLETE,          (PS8)"ScanComplete" },
    137     { IPC_EVENT_SCAN_STOPPED,           (PS8)"ScanStopped" },
    138 #ifdef XCC_MODULE_INCLUDED
    139     { IPC_EVENT_CCKM_START,             (PS8)"CCKM_Start" },
    140 #endif
    141     { IPC_EVENT_MEDIA_SPECIFIC,         (PS8)"Media_Specific" },
    142     { IPC_EVENT_EAPOL,                  (PS8)"EAPOL" },
    143     { IPC_EVENT_RE_AUTH_STARTED,		(PS8)"IPC_EVENT_RE_AUTH_STARTED" },
    144     { IPC_EVENT_RE_AUTH_COMPLETED,		(PS8)"IPC_EVENT_RE_AUTH_COMPLETED" },
    145     { IPC_EVENT_RE_AUTH_TERMINATED,     (PS8)"IPC_EVENT_RE_AUTH_TERMINATED" },
    146     { IPC_EVENT_BOUND,                  (PS8)"Bound" },
    147     { IPC_EVENT_UNBOUND,                (PS8)"Unbound" },
    148 #ifdef WPA_ENTERPRISE
    149     { IPC_EVENT_PREAUTH_EAPOL,          (PS8)"PreAuth EAPOL"},
    150 #endif
    151     { IPC_EVENT_LOW_RSSI,               (PS8)"Low RSSI" },
    152     { IPC_EVENT_TSPEC_STATUS,           (PS8)"IPC_EVENT_TSPEC_STATUS" },
    153     { IPC_EVENT_TSPEC_RATE_STATUS,      (PS8)"IPC_EVENT_TSPEC_RATE_STATUS" },
    154     { IPC_EVENT_MEDIUM_TIME_CROSS,      (PS8)"IPC_EVENT_MEDIUM_TIME_CROSS" },
    155     { IPC_EVENT_ROAMING_COMPLETE,       (PS8)"ROAMING_COMPLETE"},
    156     { IPC_EVENT_EAP_AUTH_FAILURE,       (PS8)"EAP-FAST/LEAP Auth Failed"},
    157     { IPC_EVENT_WPA2_PREAUTHENTICATION, (PS8)"IPC_EVENT_WPA2_PREAUTHENTICATION" },
    158     { IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, (PS8)"IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED" },
    159     { IPC_EVENT_SCAN_FAILED,			(PS8)"ScanFailed" },
    160     { IPC_EVENT_WPS_SESSION_OVERLAP,    (PS8)"IPC_EVENT_WPS_SESSION_OVERLAP" },
    161     { IPC_EVENT_RSSI_SNR_TRIGGER,       (PS8)"IPC_EVENT_RSSI_SNR_TRIGGER" },
    162     { IPC_EVENT_TIMEOUT,                (PS8)"Timeout" }
    163 };
    164 
    165 static named_value_t report_module[] =
    166 {
    167     { FILE_ID_0   ,  (PS8)"timer                   " },
    168     { FILE_ID_1   ,  (PS8)"measurementMgr          " },
    169     { FILE_ID_2   ,  (PS8)"measurementMgrSM        " },
    170     { FILE_ID_3   ,  (PS8)"regulatoryDomain        " },
    171     { FILE_ID_4   ,  (PS8)"requestHandler          " },
    172     { FILE_ID_5   ,  (PS8)"SoftGemini              " },
    173     { FILE_ID_6   ,  (PS8)"spectrumMngmntMgr       " },
    174     { FILE_ID_7   ,  (PS8)"SwitchChannel           " },
    175     { FILE_ID_8   ,  (PS8)"roamingMngr             " },
    176     { FILE_ID_9   ,  (PS8)"scanMngr                " },
    177     { FILE_ID_10  ,  (PS8)"admCtrlXCC              " },
    178     { FILE_ID_11  ,  (PS8)"XCCMngr                 " },
    179     { FILE_ID_12  ,  (PS8)"XCCRMMngr               " },
    180     { FILE_ID_13  ,  (PS8)"XCCTSMngr               " },
    181     { FILE_ID_14  ,  (PS8)"rogueAp                 " },
    182     { FILE_ID_15  ,  (PS8)"TransmitPowerXCC        " },
    183     { FILE_ID_16  ,  (PS8)"admCtrl                 " },
    184     { FILE_ID_17  ,  (PS8)"admCtrlNone             " },
    185     { FILE_ID_18  ,  (PS8)"admCtrlWep              " },
    186     { FILE_ID_19  ,  (PS8)"admCtrlWpa              " },
    187     { FILE_ID_20  ,  (PS8)"admCtrlWpa2             " },
    188     { FILE_ID_21  ,  (PS8)"apConn                  " },
    189     { FILE_ID_22  ,  (PS8)"broadcastKey802_1x      " },
    190     { FILE_ID_23  ,  (PS8)"broadcastKeyNone        " },
    191     { FILE_ID_24  ,  (PS8)"broadcastKeySM          " },
    192     { FILE_ID_25  ,  (PS8)"conn                    " },
    193     { FILE_ID_26  ,  (PS8)"connIbss                " },
    194     { FILE_ID_27  ,  (PS8)"connInfra               " },
    195     { FILE_ID_28  ,  (PS8)"keyDerive               " },
    196     { FILE_ID_29  ,  (PS8)"keyDeriveAes            " },
    197     { FILE_ID_30  ,  (PS8)"keyDeriveCkip           " },
    198     { FILE_ID_31  ,  (PS8)"keyDeriveTkip           " },
    199     { FILE_ID_32  ,  (PS8)"keyDeriveWep            " },
    200     { FILE_ID_33  ,  (PS8)"keyParser               " },
    201     { FILE_ID_34  ,  (PS8)"keyParserExternal       " },
    202     { FILE_ID_35  ,  (PS8)"keyParserWep            " },
    203     { FILE_ID_36  ,  (PS8)"mainKeysSm              " },
    204     { FILE_ID_37  ,  (PS8)"mainSecKeysOnly         " },
    205     { FILE_ID_38  ,  (PS8)"mainSecNull             " },
    206     { FILE_ID_39  ,  (PS8)"mainSecSm               " },
    207     { FILE_ID_40  ,  (PS8)"rsn                     " },
    208     { FILE_ID_41  ,  (PS8)"sme                     " },
    209     { FILE_ID_42  ,  (PS8)"smeSelect               " },
    210     { FILE_ID_43  ,  (PS8)"smeSm                   " },
    211     { FILE_ID_44  ,  (PS8)"unicastKey802_1x        " },
    212     { FILE_ID_45  ,  (PS8)"unicastKeyNone          " },
    213     { FILE_ID_46  ,  (PS8)"unicastKeySM            " },
    214     { FILE_ID_47  ,  (PS8)"CmdDispatcher           " },
    215     { FILE_ID_48  ,  (PS8)"CmdHndlr                " },
    216     { FILE_ID_49  ,  (PS8)"DrvMain                 " },
    217     { FILE_ID_50  ,  (PS8)"EvHandler               " },
    218     { FILE_ID_51  ,  (PS8)"Ctrl                    " },
    219     { FILE_ID_52  ,  (PS8)"GeneralUtil             " },
    220     { FILE_ID_53  ,  (PS8)"RateAdaptation          " },
    221     { FILE_ID_54  ,  (PS8)"rx                      " },
    222     { FILE_ID_55  ,  (PS8)"TrafficMonitor          " },
    223     { FILE_ID_56  ,  (PS8)"txCtrl                  " },
    224     { FILE_ID_57  ,  (PS8)"txCtrlParams            " },
    225     { FILE_ID_58  ,  (PS8)"txCtrlServ              " },
    226     { FILE_ID_59  ,  (PS8)"TxDataClsfr             " },
    227     { FILE_ID_60  ,  (PS8)"txDataQueue             " },
    228     { FILE_ID_61  ,  (PS8)"txMgmtQueue             " },
    229     { FILE_ID_62  ,  (PS8)"txPort                  " },
    230     { FILE_ID_63  ,  (PS8)"assocSM                 " },
    231     { FILE_ID_64  ,  (PS8)"authSm                  " },
    232     { FILE_ID_65  ,  (PS8)"currBss                 " },
    233     { FILE_ID_66  ,  (PS8)"healthMonitor           " },
    234     { FILE_ID_67  ,  (PS8)"mlmeBuilder             " },
    235     { FILE_ID_68  ,  (PS8)"mlmeParser              " },
    236     { FILE_ID_69  ,  (PS8)"mlmeSm                  " },
    237     { FILE_ID_70  ,  (PS8)"openAuthSm              " },
    238     { FILE_ID_71  ,  (PS8)"PowerMgr                " },
    239     { FILE_ID_72  ,  (PS8)"PowerMgrDbgPrint        " },
    240     { FILE_ID_73  ,  (PS8)"PowerMgrKeepAlive       " },
    241     { FILE_ID_74  ,  (PS8)"qosMngr                 " },
    242     { FILE_ID_75  ,  (PS8)"roamingInt              " },
    243     { FILE_ID_76  ,  (PS8)"ScanCncn                " },
    244     { FILE_ID_77  ,  (PS8)"ScanCncnApp             " },
    245     { FILE_ID_78  ,  (PS8)"ScanCncnOsSm            " },
    246     { FILE_ID_79  ,  (PS8)"ScanCncnSm              " },
    247     { FILE_ID_80  ,  (PS8)"ScanCncnSmSpecific      " },
    248     { FILE_ID_81  ,  (PS8)"scanResultTable         " },
    249     { FILE_ID_82  ,  (PS8)"scr                     " },
    250     { FILE_ID_83  ,  (PS8)"sharedKeyAuthSm         " },
    251     { FILE_ID_84  ,  (PS8)"siteHash                " },
    252     { FILE_ID_85  ,  (PS8)"siteMgr                 " },
    253     { FILE_ID_86  ,  (PS8)"StaCap                  " },
    254     { FILE_ID_87  ,  (PS8)"systemConfig            " },
    255     { FILE_ID_88  ,  (PS8)"templates               " },
    256     { FILE_ID_89  ,  (PS8)"trafficAdmControl       " },
    257     { FILE_ID_90  ,  (PS8)"CmdBld                  " },
    258     { FILE_ID_91  ,  (PS8)"CmdBldCfg               " },
    259     { FILE_ID_92  ,  (PS8)"CmdBldCfgIE             " },
    260     { FILE_ID_93  ,  (PS8)"CmdBldCmd               " },
    261     { FILE_ID_94  ,  (PS8)"CmdBldCmdIE             " },
    262     { FILE_ID_95  ,  (PS8)"CmdBldItr               " },
    263     { FILE_ID_96  ,  (PS8)"CmdBldItrIE             " },
    264     { FILE_ID_97  ,  (PS8)"CmdQueue                " },
    265     { FILE_ID_98  ,  (PS8)"RxQueue                 " },
    266     { FILE_ID_99  ,  (PS8)"txCtrlBlk               " },
    267     { FILE_ID_100 ,  (PS8)"txHwQueue               " },
    268     { FILE_ID_101 ,  (PS8)"CmdMBox                 " },
    269     { FILE_ID_102 ,  (PS8)"eventMbox               " },
    270     { FILE_ID_103 ,  (PS8)"fwDebug                 " },
    271     { FILE_ID_104 ,  (PS8)"FwEvent                 " },
    272     { FILE_ID_105 ,  (PS8)"HwInit                  " },
    273     { FILE_ID_106 ,  (PS8)"RxXfer                  " },
    274     { FILE_ID_107 ,  (PS8)"txResult                " },
    275     { FILE_ID_108 ,  (PS8)"txXfer                  " },
    276     { FILE_ID_109 ,  (PS8)"MacServices             " },
    277     { FILE_ID_110 ,  (PS8)"MeasurementSrv          " },
    278     { FILE_ID_111 ,  (PS8)"measurementSrvDbgPrint  " },
    279     { FILE_ID_112 ,  (PS8)"MeasurementSrvSM        " },
    280     { FILE_ID_113 ,  (PS8)"PowerSrv                " },
    281     { FILE_ID_114 ,  (PS8)"PowerSrvSM              " },
    282     { FILE_ID_115 ,  (PS8)"ScanSrv                 " },
    283     { FILE_ID_116 ,  (PS8)"ScanSrvSM               " },
    284     { FILE_ID_117 ,  (PS8)"TWDriver                " },
    285     { FILE_ID_118 ,  (PS8)"TWDriverCtrl            " },
    286     { FILE_ID_119 ,  (PS8)"TWDriverRadio           " },
    287     { FILE_ID_120 ,  (PS8)"TWDriverTx              " },
    288     { FILE_ID_121 ,  (PS8)"TwIf                    " },
    289     { FILE_ID_122 ,  (PS8)"SdioBusDrv              " },
    290     { FILE_ID_123 ,  (PS8)"TxnQueue                " },
    291     { FILE_ID_124 ,  (PS8)"WspiBusDrv              " },
    292     { FILE_ID_125 ,  (PS8)"context                 " },
    293     { FILE_ID_126 ,  (PS8)"freq                    " },
    294     { FILE_ID_127 ,  (PS8)"fsm                     " },
    295     { FILE_ID_128 ,  (PS8)"GenSM                   " },
    296     { FILE_ID_129 ,  (PS8)"mem                     " },
    297     { FILE_ID_130 ,  (PS8)"queue                   " },
    298     { FILE_ID_131 ,  (PS8)"rate                    " },
    299     { FILE_ID_132 ,  (PS8)"report                  " },
    300     { FILE_ID_133 ,  (PS8)"stack                   " },
    301 	{ FILE_ID_134 ,  (PS8)"externalSec             " },
    302 	{ FILE_ID_135 ,  (PS8)"roamingMngr_autoSM      " },
    303 	{ FILE_ID_136 ,  (PS8)"roamingMngr_manualSM    " },
    304 	{ FILE_ID_137 ,  (PS8)"cmdinterpretoid         " },
    305 	{ FILE_ID_138 ,  (PS8)"WlanDrvIf               " }
    306 };
    307 
    308 static named_value_t report_severity[] = {
    309     { 0,                          (PS8)"----"           },
    310     { REPORT_SEVERITY_INIT,         (PS8)"INIT",          },
    311     { REPORT_SEVERITY_INFORMATION,  (PS8)"INFORMATION",   },
    312     { REPORT_SEVERITY_WARNING,      (PS8)"WARNING",       },
    313     { REPORT_SEVERITY_ERROR,        (PS8)"ERROR",         },
    314     { REPORT_SEVERITY_FATAL_ERROR,  (PS8)"FATAL_ERROR",   },
    315     { REPORT_SEVERITY_SM,           (PS8)"SM",            },
    316     { REPORT_SEVERITY_CONSOLE,      (PS8)"CONSOLE"        }
    317 };
    318 
    319 static named_value_t power_level[] = {
    320         { OS_POWER_LEVEL_ELP,       (PS8)"Extreme Low Power" },
    321         { OS_POWER_LEVEL_PD,        (PS8)"Power Down" },
    322         { OS_POWER_LEVEL_AWAKE,     (PS8)"Awake" },
    323 };
    324 
    325 static named_value_t band2Str[] = {
    326         { RADIO_BAND_2_4_GHZ,                   (PS8)"2.4 GHz"                        },
    327         { RADIO_BAND_5_0_GHZ,                   (PS8)"5.0 GHz"                        },
    328         { RADIO_BAND_DUAL,                      (PS8)"Both   "                        }
    329 };
    330 
    331 static named_value_t EtEvent2Str[] = {
    332         { SCAN_ET_COND_DISABLE,                 (PS8)"ET disabled  "                     },
    333         { SCAN_ET_COND_BEACON,                  (PS8)"ET on Beacon "                     },
    334         { SCAN_ET_COND_PROBE_RESP,              (PS8)"ET on Prb Rsp"                     },
    335         { SCAN_ET_COND_ANY_FRAME,               (PS8)"ET on both   "                     }
    336 };
    337 
    338 static named_value_t rate2Str[] = {
    339         { DRV_RATE_MASK_AUTO,                   (PS8)"Auto    "                          },
    340         { DRV_RATE_MASK_1_BARKER,               (PS8)"1 Mbps  "                          },
    341         { DRV_RATE_MASK_2_BARKER,               (PS8)"2 Mbps  "                          },
    342         { DRV_RATE_MASK_5_5_CCK,                (PS8)"5.5 Mbps"                          },
    343         { DRV_RATE_MASK_11_CCK,                 (PS8)"11 Mbps "                          },
    344         { DRV_RATE_MASK_22_PBCC,                (PS8)"22 Mbps "                          },
    345         { DRV_RATE_MASK_6_OFDM,                 (PS8)"6 Mbps  "                          },
    346         { DRV_RATE_MASK_9_OFDM,                 (PS8)"9 Mbps  "                          },
    347         { DRV_RATE_MASK_12_OFDM,                (PS8)"12 Mbps "                          },
    348         { DRV_RATE_MASK_18_OFDM,                (PS8)"18 Mbps "                          },
    349         { DRV_RATE_MASK_24_OFDM,                (PS8)"24 Mbps "                          },
    350         { DRV_RATE_MASK_36_OFDM,                (PS8)"36 Mbps "                          },
    351         { DRV_RATE_MASK_48_OFDM,                (PS8)"48 Mbps "                          },
    352         { DRV_RATE_MASK_54_OFDM,                (PS8)"54 Mbps "                          }
    353 };
    354 
    355 static named_value_t scanType2Str[] = {
    356         { SCAN_TYPE_NORMAL_PASSIVE,             (PS8)"Passive Normal Scan"               },
    357         { SCAN_TYPE_NORMAL_ACTIVE,              (PS8)"Active Normal Scan"                },
    358         { SCAN_TYPE_SPS,                        (PS8)"Scheduled Passive Scan (SPS)"      },
    359         { SCAN_TYPE_TRIGGERED_PASSIVE,          (PS8)"Passive Triggered Scan"            },
    360         { SCAN_TYPE_TRIGGERED_ACTIVE,           (PS8)"Active Triggered Scan"             }
    361 };
    362 
    363 static named_value_t booleanStr[] = {
    364         { FALSE,                             (PS8)"False" },
    365         { TRUE,                              (PS8)"True" }
    366 };
    367 
    368 static named_value_t ssidVisabilityStr[] = {
    369         { SCAN_SSID_VISABILITY_PUBLIC,          (PS8)"Public" },
    370         { SCAN_SSID_VISABILITY_HIDDEN,          (PS8)"Hidden" }
    371 };
    372 
    373 static named_value_t bssTypeStr[] = {
    374         { BSS_INDEPENDENT,                      (PS8)"Independent" },
    375         { BSS_INFRASTRUCTURE,                   (PS8)"Infrastructure" },
    376         { BSS_ANY,                              (PS8)"Any" }
    377 };
    378 
    379 static named_value_t power_mode_val[] = {
    380         { OS_POWER_MODE_AUTO,                   (PS8)"AUTO" },
    381         { OS_POWER_MODE_ACTIVE,                 (PS8)"ACTIVE" },
    382         { OS_POWER_MODE_SHORT_DOZE,             (PS8)"SHORT_DOZE" },
    383         { OS_POWER_MODE_LONG_DOZE,              (PS8)"LONG_DOZE" }
    384 };
    385 
    386 static named_value_t encrypt_type[] = {
    387         { OS_ENCRYPTION_TYPE_NONE,              (PS8)"None" },
    388         { OS_ENCRYPTION_TYPE_WEP,               (PS8)"WEP" },
    389         { OS_ENCRYPTION_TYPE_TKIP,              (PS8)"TKIP" },
    390         { OS_ENCRYPTION_TYPE_AES,               (PS8)"AES" }
    391 };
    392 
    393 static named_value_t tKeepAliveTriggerTypes[] = {
    394         { KEEP_ALIVE_TRIG_TYPE_NO_TX,           (PS8)"When Idle" },
    395         { KEEP_ALIVE_TRIG_TYPE_PERIOD_ONLY,     (PS8)"Always" }
    396 };
    397 
    398 #if 0 /* need to create debug logic for CLI */
    399 static named_value_t cli_level_type[] = {
    400         { CU_MSG_DEBUG,                         (PS8)"CU_MSG_DEBUG" },
    401         { CU_MSG_INFO1,                         (PS8)"CU_MSG_INFO1" },
    402         { CU_MSG_WARNING,                       (PS8)"CU_MSG_WARNING" },
    403         { CU_MSG_ERROR,                         (PS8)"CU_MSG_ERROR" },
    404         { CU_MSG_INFO2,                         (PS8)"CU_MSG_INFO2" }
    405 };
    406 #endif
    407 
    408 
    409 static char *ConnState[] = {
    410   "IDLE",
    411   "SCANNING",
    412   "CONNECTING",
    413   "CONNECTED",
    414   "DISCONNECT",
    415   "IDLE"
    416 };
    417 
    418 
    419 
    420 static char ssidBuf[MAX_SSID_LEN +1];
    421 
    422 /* local fucntions */
    423 /*******************/
    424 static S32 CuCmd_Str2MACAddr(PS8 str, PU8 mac)
    425 {
    426     S32 i;
    427 
    428     for( i=0; i<MAC_ADDR_LEN; i++ )
    429     {
    430         mac[i] = (U8) os_strtoul(str, &str, 16);
    431         str++;
    432     }
    433     return TRUE;
    434 }
    435 
    436 /* used in get_bssid_list() */
    437 static U8 CuCmd_Freq2Chan(U32 freq)
    438 {
    439     U32 i;
    440 
    441     for(i=0; i<CHAN_FREQ_TABLE_SIZE; i++)
    442         if(ChanFreq[i].freq == freq)
    443             return ChanFreq[i].chan;
    444 
    445     return 0;
    446 }
    447 
    448 /* Converts a single ASCII character to a hex value (i.e. '0'-'9' = 0-9, 'a'-'f' = a-f, 'A'-'F' = a-f) */
    449 static U8 CuCmd_atox(U8 c)
    450 {
    451     if (('0' <= c) && ('9' >= c))
    452     {
    453         return c - '0';
    454     }
    455     else if (('a' <= c) && ('f' >= c))
    456     {
    457         return c - 'a' + 10;
    458     }
    459     else /* assuming input is valid */
    460     {
    461         return c - 'A' + 10;
    462     }
    463 }
    464 
    465 /* converts an ASCII string to a buffer */
    466 static void CuCmd_atox_string (U8* srcString, U8* dstBuffer)
    467 {
    468     U32 uIndex, uLength;
    469 
    470     uLength = os_strlen ((PS8)srcString);
    471 
    472     /* clear the destination buffer */
    473     os_memset (dstBuffer, 0, (uLength / 2) + 1);
    474 
    475     for (uIndex = 0; uIndex < uLength; uIndex++)
    476     {
    477         if (0 == (uIndex % 2))
    478         {
    479             dstBuffer[ uIndex / 2 ] |= (CuCmd_atox (srcString[ uIndex ]) << 4);
    480         }
    481         else
    482         {
    483             dstBuffer[ uIndex / 2 ] |= CuCmd_atox (srcString[ uIndex ]);
    484         }
    485     }
    486 }
    487 
    488 static void CuCmd_xtoa_string (U8* srcBuffer, U32 srcBufferLength, U8* dstString)
    489 {
    490     U32 uIndex;
    491 
    492     for (uIndex = 0; uIndex < srcBufferLength; uIndex++)
    493     {
    494         os_sprintf ((PS8)&(dstString[ uIndex * 2 ]), (PS8)"%02x", srcBuffer[ uIndex ]);
    495     }
    496 }
    497 
    498 static VOID CuCmd_Init_Scan_Params(CuCmd_t* pCuCmd)
    499 {
    500     U8 i,j;
    501 
    502     /* init application scan default params */
    503     pCuCmd->appScanParams.desiredSsid.len = 0;
    504     pCuCmd->appScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    505     pCuCmd->appScanParams.band = RADIO_BAND_2_4_GHZ;
    506     pCuCmd->appScanParams.probeReqNumber = 3;
    507     pCuCmd->appScanParams.probeRequestRate = RATE_MASK_UNSPECIFIED; /* Let the FW select */;
    508     pCuCmd->appScanParams.numOfChannels = 14;
    509     for ( i = 0; i < 14; i++ )
    510     {
    511         for ( j = 0; j < 6; j++ )
    512         {
    513             pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.bssId[ j ] = 0xff;
    514         }
    515         pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
    516         pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes = 0;
    517         pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.maxChannelDwellTime = 60000;
    518         pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.minChannelDwellTime = 30000;
    519         pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.txPowerDbm = DEF_TX_POWER;
    520         pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.channel = i + 1;
    521     }
    522 
    523     /* init periodic application scan params */
    524     pCuCmd->tPeriodicAppScanParams.uSsidNum = 0;
    525     pCuCmd->tPeriodicAppScanParams.uSsidListFilterEnabled = 1;
    526     pCuCmd->tPeriodicAppScanParams.uCycleNum = 0; /* forever */
    527     pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ 0 ] = 3;
    528     for (i = 1; i < PERIODIC_SCAN_MAX_INTERVAL_NUM; i++)
    529     {
    530         pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ i ] = 30000;
    531     }
    532     pCuCmd->tPeriodicAppScanParams.iRssiThreshold = -80;
    533     pCuCmd->tPeriodicAppScanParams.iSnrThreshold = 0;
    534     pCuCmd->tPeriodicAppScanParams.uFrameCountReportThreshold = 1;
    535     pCuCmd->tPeriodicAppScanParams.bTerminateOnReport = TRUE;
    536     pCuCmd->tPeriodicAppScanParams.eBssType = BSS_ANY;
    537     pCuCmd->tPeriodicAppScanParams.uProbeRequestNum = 3;
    538     pCuCmd->tPeriodicAppScanParams.uChannelNum = 14;
    539     for ( i = 0; i < 14; i++ )
    540     {
    541         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eBand = RADIO_BAND_2_4_GHZ;
    542         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uChannel = i + 1;
    543         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eScanType = SCAN_TYPE_NORMAL_ACTIVE;
    544         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMinDwellTimeMs = 5;
    545         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMaxDwellTimeMs = 20;
    546         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uTxPowerLevelDbm = DEF_TX_POWER;
    547     }
    548 
    549     /* init default scan policy */
    550     pCuCmd->scanPolicy.normalScanInterval = 10000;
    551     pCuCmd->scanPolicy.deterioratingScanInterval = 5000;
    552     pCuCmd->scanPolicy.maxTrackFailures = 3;
    553     pCuCmd->scanPolicy.BSSListSize = 4;
    554     pCuCmd->scanPolicy.BSSNumberToStartDiscovery = 1;
    555     pCuCmd->scanPolicy.numOfBands = 1;
    556     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].band = RADIO_BAND_2_4_GHZ;
    557     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].rxRSSIThreshold = -80;
    558     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].numOfChannles = 14;
    559     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].numOfChannlesForDiscovery = 3;
    560     for ( i = 0; i < 14; i++ )
    561     {
    562         pCuCmd->scanPolicy.bandScanPolicy[ 0 ].channelList[ i ] = i + 1;
    563     }
    564     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    565     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
    566     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
    567     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
    568     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.minChannelDwellTime = 15000;
    569     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.bitrate = RATE_MASK_UNSPECIFIED; /* Let the FW select */
    570     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
    571     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = DEF_TX_POWER;
    572     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    573     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
    574     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
    575     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
    576     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.minChannelDwellTime = 15000;
    577     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.bitrate = RATE_MASK_UNSPECIFIED; /* Let the FW select */;
    578     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
    579     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = DEF_TX_POWER;
    580     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    581     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
    582     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
    583     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
    584     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.minChannelDwellTime = 15000;
    585     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = RATE_MASK_UNSPECIFIED; /* Let the FW select */;
    586     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
    587     pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = DEF_TX_POWER;
    588 }
    589 
    590 char* PrintSSID(OS_802_11_SSID* ssid)
    591 {
    592     /* It looks like it never happens. Anyway decided to check */
    593 	if(ssid->SsidLength > MAX_SSID_LEN)
    594     {
    595 
    596         os_error_printf(CU_MSG_ERROR, (PS8)"PrintSSID. ssid->SsidLength=%d exceeds the limit %d\n",
    597                          ssid->SsidLength, MAX_SSID_LEN);
    598         /*WLAN_OS_REPORT(("PrintSSID. ssid->SsidLength=%d exceeds the limit %d\n",
    599                    ssid->SsidLength, MAX_SSID_LEN));*/
    600         ssid->SsidLength = MAX_SSID_LEN;
    601     }
    602 	os_memcpy((PVOID)ssidBuf, (PVOID) ssid->Ssid, ssid->SsidLength);
    603 	ssidBuf[ssid->SsidLength] = '\0';
    604 	return ssidBuf;
    605 }
    606 
    607 static VOID CuCmd_PrintBssidList(OS_802_11_BSSID_LIST_EX* bssidList, S32 IsFullPrint, TMacAddr CurrentBssid)
    608 {
    609     U32 i;
    610     S8  connectionTypeStr[50];
    611     POS_802_11_BSSID_EX pBssid = &bssidList->Bssid[0];
    612 
    613     os_error_printf(CU_MSG_INFO2, (PS8)"BssId List: Num=%u\n", bssidList->NumberOfItems);
    614     os_error_printf(CU_MSG_INFO2, (PS8)"         MAC        Privacy Rssi  Mode    Channel    SSID\n");
    615     for(i=0; i<bssidList->NumberOfItems; i++)
    616     {
    617         switch (pBssid->InfrastructureMode)
    618         {
    619             case os802_11IBSS:
    620                 os_strcpy (connectionTypeStr, (PS8)"Adhoc");
    621                 break;
    622             case os802_11Infrastructure:
    623                 os_strcpy (connectionTypeStr, (PS8)"Infra");
    624                 break;
    625             case os802_11AutoUnknown:
    626                 os_strcpy (connectionTypeStr, (PS8)"Auto");
    627                 break;
    628             default:
    629                 os_strcpy (connectionTypeStr, (PS8)" --- ");
    630                 break;
    631         }
    632         os_error_printf(CU_MSG_INFO2, (PS8)"%s%02x.%02x.%02x.%02x.%02x.%02x   %3u   %4d  %s %6d        %s\n",
    633             (!os_memcmp(CurrentBssid, pBssid->MacAddress, MAC_ADDR_LEN))?"*":" ",
    634             pBssid->MacAddress[0],
    635             pBssid->MacAddress[1],
    636             pBssid->MacAddress[2],
    637             pBssid->MacAddress[3],
    638             pBssid->MacAddress[4],
    639             pBssid->MacAddress[5],
    640             pBssid->Privacy,
    641 			(char)pBssid->Rssi | 0xffffff00, /* need the 0xffffff00 to get negative value display */
    642             connectionTypeStr,
    643             CuCmd_Freq2Chan(pBssid->Configuration.Union.channel),
    644             (pBssid->Ssid.Ssid[0] == '\0')?(PS8)"****":((PS8)pBssid->Ssid.Ssid) );
    645 
    646         if (IsFullPrint)
    647         {
    648             os_error_printf(CU_MSG_INFO2, (PS8)"   BeaconInterval %d\n",  pBssid->Configuration.BeaconPeriod);
    649             os_error_printf(CU_MSG_INFO2, (PS8)"   Capabilities   0x%x\n",  pBssid->Capabilities);
    650         }
    651 #ifdef _WINDOWS
    652 		pBssid = (POS_802_11_BSSID_EX)((S8*)pBssid + (pBssid->Length ? pBssid->Length : sizeof(OS_802_11_BSSID_EX)));
    653 #else /*for Linux*/
    654 		pBssid = &bssidList->Bssid[i+1];
    655 #endif
    656     }
    657 }
    658 
    659 static U8 CuCmd_Char2Hex( S8 c )
    660 {
    661     if( c >= '0' && c <= '9' )
    662         return c - '0';
    663     else if( os_tolower(c) >= 'a' && os_tolower(c) <= 'f' )
    664         return (U8) (os_tolower(c) - 'a' + 0x0a);
    665     os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Char2Hex - invalid symbol '%c'\n", c );
    666     return ((U8)-1);
    667 }
    668 
    669 static PS8 CuCmd_CreateRateStr(PS8 str, U8 rate)
    670 {
    671     if( rate == 0 )
    672         return os_strcpy(str,(PS8)"Auto (0)");
    673 
    674     os_sprintf(str, (PS8)"%.3g Mbps",
    675         RATE_2_MBPS(rate));
    676 
    677     return str;
    678 }
    679 
    680 static VOID CuCmd_PrintScanMethod(scan_Method_t* scanMethod)
    681 {
    682     S32 i;
    683     os_error_printf(CU_MSG_INFO2, (PS8)"Scan type: %s\n", scanType2Str[ scanMethod->scanType ].name);
    684     switch (scanMethod->scanType)
    685     {
    686         case SCAN_TYPE_NORMAL_ACTIVE:
    687         case SCAN_TYPE_NORMAL_PASSIVE:
    688             os_error_printf(CU_MSG_INFO2, (PS8)"Max channel dwell time: %d, Min channel dwell time: %d\n",
    689                 scanMethod->method.basicMethodParams.maxChannelDwellTime,
    690                 scanMethod->method.basicMethodParams.minChannelDwellTime);
    691 
    692             CU_CMD_FIND_NAME_ARRAY(i, EtEvent2Str, scanMethod->method.basicMethodParams.earlyTerminationEvent);
    693             os_error_printf(CU_MSG_INFO2 ,(PS8)"ET condition: %s, ET number of frames: %d\n",
    694                 EtEvent2Str[i].name,
    695                 scanMethod->method.basicMethodParams.ETMaxNumberOfApFrames);
    696 
    697             CU_CMD_FIND_NAME_ARRAY(i, rate2Str, scanMethod->method.basicMethodParams.probReqParams.bitrate);
    698             os_error_printf(CU_MSG_INFO2 ,(PS8)"Probe request number: %d, probe request rate: %s, TX level: %d\n",
    699                 scanMethod->method.basicMethodParams.probReqParams.numOfProbeReqs,
    700                 rate2Str[i].name,
    701                 scanMethod->method.basicMethodParams.probReqParams.txPowerDbm);
    702             break;
    703 
    704         case SCAN_TYPE_TRIGGERED_ACTIVE:
    705         case SCAN_TYPE_TRIGGERED_PASSIVE:
    706             os_error_printf(CU_MSG_INFO2, (PS8)"Triggering Tid: %d\n", scanMethod->method.TidTriggerdMethodParams.triggeringTid);
    707             os_error_printf(CU_MSG_INFO2, (PS8)"Max channel dwell time: %d, Min channel dwell time: %d\n",
    708                 scanMethod->method.basicMethodParams.maxChannelDwellTime,
    709                 scanMethod->method.basicMethodParams.minChannelDwellTime);
    710 
    711             CU_CMD_FIND_NAME_ARRAY(i, EtEvent2Str, scanMethod->method.basicMethodParams.earlyTerminationEvent);
    712             os_error_printf(CU_MSG_INFO2, (PS8)"ET condition: %s, ET number of frames: %d\n",
    713                 EtEvent2Str[i].name,
    714                 scanMethod->method.basicMethodParams.ETMaxNumberOfApFrames);
    715 
    716             CU_CMD_FIND_NAME_ARRAY(i, rate2Str, scanMethod->method.basicMethodParams.probReqParams.bitrate);
    717             os_error_printf(CU_MSG_INFO2, (PS8)"Probe request number: %d, probe request rate: %s, TX level: %d\n",
    718                 scanMethod->method.basicMethodParams.probReqParams.numOfProbeReqs,
    719                 rate2Str[i].name,
    720                 scanMethod->method.basicMethodParams.probReqParams.txPowerDbm);
    721             break;
    722 
    723         case SCAN_TYPE_SPS:
    724             CU_CMD_FIND_NAME_ARRAY(i, EtEvent2Str, scanMethod->method.spsMethodParams.earlyTerminationEvent);
    725             os_error_printf(CU_MSG_INFO2, (PS8)"ET condition: %s, ET number of frames: %d\n",
    726                 EtEvent2Str[i].name,
    727                 scanMethod->method.spsMethodParams.ETMaxNumberOfApFrames);
    728             os_error_printf(CU_MSG_INFO2, (PS8)"Scan duration: %d\n", scanMethod->method.spsMethodParams.scanDuration);
    729             break;
    730 
    731         case SCAN_TYPE_NO_SCAN:
    732         case SCAN_TYPE_PACTSIVE:
    733             break;
    734     }
    735 }
    736 
    737 static VOID CuCmd_PrintScanBand(scan_bandPolicy_t* pBandPolicy)
    738 {
    739     S32 j;
    740 
    741     os_error_printf(CU_MSG_INFO2, (PS8)"\nBand: %s\n", band2Str[ pBandPolicy->band ].name);
    742     os_error_printf(CU_MSG_INFO2, (PS8)"RSSI Threshold: %d dBm\n", pBandPolicy->rxRSSIThreshold);
    743     os_error_printf(CU_MSG_INFO2, (PS8)"Number of channels for each discovery interval: %d\n", pBandPolicy->numOfChannlesForDiscovery);
    744     os_error_printf(CU_MSG_INFO2, (PS8)"\nTracking Method:\n");
    745     CuCmd_PrintScanMethod( &(pBandPolicy->trackingMethod) );
    746     os_error_printf(CU_MSG_INFO2, (PS8)"\nDiscovery Method:\n");
    747     CuCmd_PrintScanMethod( &(pBandPolicy->discoveryMethod) );
    748     os_error_printf(CU_MSG_INFO2, (PS8)"\nImmediate Scan Method:\n");
    749     CuCmd_PrintScanMethod( &(pBandPolicy->immediateScanMethod) );
    750     if ( pBandPolicy->numOfChannles > 0 )
    751     {
    752         os_error_printf(CU_MSG_INFO2, (PS8)"\nChannel list: ");
    753         for ( j = 0; j < pBandPolicy->numOfChannles; j++ )
    754         {
    755             os_error_printf(CU_MSG_INFO2, (PS8)"%3d ", pBandPolicy->channelList[ j ]);
    756         }
    757         os_error_printf(CU_MSG_INFO2, (PS8)"\n");
    758     }
    759     else
    760     {
    761         os_error_printf(CU_MSG_INFO2, (PS8)"\nNo channels defined.\n");
    762     }
    763 }
    764 
    765 static U32 CuCmd_IsValueRate(U32 rate)
    766 {
    767 
    768     switch (rate)
    769     {
    770         case 1:
    771         case 2:
    772         case 5:
    773         case 6:
    774         case 9:
    775         case 11:
    776         case 12:
    777         case 18:
    778         case 24:
    779         case 36:
    780         case 48:
    781         case 54:
    782             return (TRUE);
    783 
    784         default:
    785             return (FALSE);
    786    }
    787 }
    788 
    789 static VOID CuCmd_ParseMaskString(PS8 pString, PU8 pBuffer, PU8 pLength)
    790 {
    791     S8  ch;
    792     S32 iter = 0;
    793     U8  val;
    794 
    795     while ((ch = pString[iter]))
    796     {
    797         val = (ch == '1' ? 1 : 0);
    798 
    799         if (iter % BIT_TO_BYTE_FACTOR)
    800             pBuffer[iter / BIT_TO_BYTE_FACTOR] |= (val << (iter % BIT_TO_BYTE_FACTOR));
    801         else
    802             pBuffer[iter / BIT_TO_BYTE_FACTOR] = val;
    803 
    804         ++iter;
    805     }
    806 
    807     /* iter = 0 len = 0, iter = 1 len = 1, iter = 8 len = 1, and so on... */
    808     *pLength = (U8) (iter + BIT_TO_BYTE_FACTOR - 1) / BIT_TO_BYTE_FACTOR;
    809 }
    810 
    811 static VOID CuCmd_ParsePatternString(PS8 pString, PU8 pBuffer, PU8 pLength)
    812 {
    813     S8 ch;
    814     S32 iter = 0;
    815     U8 val;
    816 
    817     while ((ch = pString[iter]))
    818     {
    819         val = ((ch >= '0' && ch <= '9') ? (ch - '0') :
    820                      (ch >= 'A' && ch <= 'F') ? (0xA + ch - 'A') :
    821                      (ch >= 'a' && ch <= 'f') ? (0xA + ch - 'a') : 0);
    822 
    823         /* even indexes go to the lower nibble, odd indexes push them to the */
    824         /* higher nibble and then go themselves to the lower nibble. */
    825         if (iter % 2)
    826             pBuffer[iter / 2] = ((pBuffer[iter / 2] << (BIT_TO_BYTE_FACTOR / 2)) | val);
    827         else
    828             pBuffer[iter / 2] = val;
    829 
    830         ++iter;
    831     }
    832 
    833     /* iter = 0 len = 0, iter = 1 len = 1, iter = 2 len = 1, and so on... */
    834     *pLength = (U8) (iter + 1) / 2;
    835 }
    836 
    837 /* functions */
    838 /*************/
    839 THandle CuCmd_Create(const PS8 device_name, THandle hConsole, S32 BypassSupplicant, PS8 pSupplIfFile)
    840 {
    841     THandle hIpcSta;
    842 
    843     CuCmd_t* pCuCmd = (CuCmd_t*)os_MemoryCAlloc(sizeof(CuCmd_t), sizeof(U8));
    844     if(pCuCmd == NULL)
    845     {
    846         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Create - cant allocate control block\n");
    847         return NULL;
    848     }
    849 
    850     pCuCmd->isDeviceRunning = FALSE;
    851     pCuCmd->hConsole = hConsole;
    852 
    853     pCuCmd->hCuCommon= CuCommon_Create(&hIpcSta, device_name);
    854     if(pCuCmd->hCuCommon == NULL)
    855     {
    856         CuCmd_Destroy(pCuCmd);
    857         return NULL;
    858     }
    859 
    860     pCuCmd->hCuWext= CuOs_Create(hIpcSta);
    861     if(pCuCmd->hCuWext == NULL)
    862     {
    863         CuCmd_Destroy(pCuCmd);
    864         return NULL;
    865     }
    866 
    867     pCuCmd->hIpcEvent = (THandle) IpcEvent_Create();
    868     if(pCuCmd->hIpcEvent == NULL)
    869     {
    870         CuCmd_Destroy(pCuCmd);
    871         return NULL;
    872     }
    873 
    874     if(BypassSupplicant)
    875     {
    876         /* specify that there is no supplicant */
    877         pCuCmd->hWpaCore = NULL;
    878     }
    879     else
    880     {
    881 #ifndef NO_WPA_SUPPL
    882         S32 res;
    883 
    884         pCuCmd->hWpaCore = WpaCore_Create(&res, pSupplIfFile);
    885         if((pCuCmd->hWpaCore == NULL) && (res != EOALERR_IPC_WPA_ERROR_CANT_CONNECT_TO_SUPPL))
    886         {
    887             CuCmd_Destroy(pCuCmd);
    888             return NULL;
    889         }
    890 
    891         if(res == EOALERR_IPC_WPA_ERROR_CANT_CONNECT_TO_SUPPL)
    892         {
    893             os_error_printf(CU_MSG_ERROR, (PS8)"******************************************************\n");
    894             os_error_printf(CU_MSG_ERROR, (PS8)"Connection to supplicant failed\n");
    895             os_error_printf(CU_MSG_ERROR, (PS8)"******************************************************\n");
    896         }
    897         else
    898         {
    899             os_error_printf(CU_MSG_INFO2, (PS8)"Connection established with supplicant\n");
    900         }
    901 #endif
    902     }
    903 
    904     CuCmd_Init_Scan_Params(pCuCmd);
    905 
    906     return pCuCmd;
    907 }
    908 
    909 VOID CuCmd_Destroy(THandle hCuCmd)
    910 {
    911     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
    912 
    913     if(pCuCmd->hCuCommon)
    914     {
    915         CuCommon_Destroy(pCuCmd->hCuCommon);
    916     }
    917 
    918     if(pCuCmd->hCuWext)
    919     {
    920         CuOs_Destroy(pCuCmd->hCuWext);
    921     }
    922 
    923     if(pCuCmd->hIpcEvent)
    924     {
    925         IpcEvent_Destroy(pCuCmd->hIpcEvent);
    926     }
    927 
    928 #ifndef NO_WPA_SUPPL
    929     if(pCuCmd->hWpaCore)
    930     {
    931         WpaCore_Destroy(pCuCmd->hWpaCore);
    932     }
    933 #endif
    934 
    935     os_MemoryFree(pCuCmd);
    936 }
    937 
    938 S32 CuCmd_GetDeviceStatus(THandle hCuCmd)
    939 {
    940     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
    941     S32 status;
    942 
    943     status = CuCommon_GetU32(pCuCmd->hCuCommon, DRIVER_STATUS_PARAM, &pCuCmd->isDeviceRunning);
    944 
    945     if ((status == OK) && pCuCmd->isDeviceRunning)
    946         return OK;
    947 
    948     return ECUERR_CU_CMD_ERROR_DEVICE_NOT_LOADED;
    949 }
    950 
    951 VOID CuCmd_StartDriver(THandle hCuCmd)
    952 {
    953     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
    954     U32 uDummyBuf;
    955 
    956     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, DRIVER_START_PARAM, &uDummyBuf, sizeof(uDummyBuf)))
    957     {
    958         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Failed to start driver!\n");
    959     }
    960 }
    961 
    962 VOID CuCmd_StopDriver(THandle hCuCmd)
    963 {
    964     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
    965     U32 uDummyBuf;
    966 
    967     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, DRIVER_STOP_PARAM, &uDummyBuf, sizeof(uDummyBuf)))
    968     {
    969         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Failed to stop driver!\n");
    970     }
    971 }
    972 
    973 #ifdef XCC_MODULE_INCLUDED
    974 THandle CuCmd_GetCuCommonHandle(THandle hCuCmd)
    975 {
    976     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
    977 
    978     return pCuCmd->hCuCommon;
    979 }
    980 
    981 THandle CuCmd_GetCuWpaHandle (THandle hCuCmd)
    982 {
    983     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
    984 
    985     return pCuCmd->hWpaCore;
    986 
    987 }
    988 #endif
    989 
    990 VOID CuCmd_Show_Status(THandle hCuCmd, ConParm_t parm[], U16 nParms)
    991 {
    992     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
    993 
    994     TMacAddr Mac;
    995     OS_802_11_SSID ssid;
    996     TMacAddr bssid;
    997     U32 channel, threadid=0;
    998     U32 status ;
    999 
   1000     if(OK != CuCmd_GetDeviceStatus(hCuCmd))
   1001     {
   1002         os_error_printf(CU_MSG_INFO2, (PS8)"Driver is stopped!\n");
   1003         return;
   1004     }
   1005 
   1006     CuOs_GetDriverThreadId(pCuCmd->hCuWext, &threadid);
   1007     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, CTRL_DATA_MAC_ADDRESS, Mac, sizeof(TMacAddr))) return;
   1008     if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return;
   1009     if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid)) return;
   1010     if(OK != CuOs_GetCurrentChannel(pCuCmd->hCuWext, &channel)) return;
   1011     if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, SME_CONNECTION_STATUS_PARAM, &status))
   1012       os_error_printf(CU_MSG_INFO2, (PS8)"can't read connection status!\n");
   1013 
   1014     if (threadid != 0)
   1015     {
   1016         os_error_printf(CU_MSG_INFO2, (PS8)"Thread id: %u (0x%x)\n\n", threadid, threadid);
   1017     }
   1018     os_error_printf(CU_MSG_INFO2, (PS8)"==========================\n");
   1019     os_error_printf(CU_MSG_INFO2, (PS8)"Status   : %s\n",ConnState[status]);
   1020     os_error_printf(CU_MSG_INFO2, (PS8)"MAC      : %02x.%02x.%02x.%02x.%02x.%02x\n",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);
   1021     os_error_printf(CU_MSG_INFO2, (PS8)"SSID     : %s\n",(ssid.SsidLength)?PrintSSID(&ssid):"<empty>");
   1022     os_error_printf(CU_MSG_INFO2, (PS8)"BSSID    : %02x.%02x.%02x.%02x.%02x.%02x\n",bssid[0],bssid[1],bssid[2],bssid[3],bssid[4],bssid[5]);
   1023     if(channel)
   1024         os_error_printf(CU_MSG_INFO2, (PS8)"Channel  : %d\n",channel);
   1025     else
   1026         os_error_printf(CU_MSG_INFO2, (PS8)"Channel  : <empty>\n");
   1027     os_error_printf(CU_MSG_INFO2, (PS8)"==========================\n");
   1028 
   1029 }
   1030 
   1031 VOID CuCmd_BssidList(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1032 {
   1033     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1034     U32 SizeOfBssiList=0;
   1035     OS_802_11_BSSID_LIST_EX* bssidList;
   1036     TMacAddr bssid;
   1037 
   1038     if(OK != CuCommon_Get_BssidList_Size(pCuCmd->hCuCommon, &SizeOfBssiList))
   1039     {
   1040         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant get Bssid list size\n");
   1041         return;
   1042     }
   1043 
   1044     /* allocate the bssidList */
   1045     bssidList = os_MemoryCAlloc(SizeOfBssiList, sizeof(U8));
   1046     if(bssidList == NULL)
   1047     {
   1048         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant allocate Bssid list\n");
   1049         return;
   1050     }
   1051 
   1052     if(SizeOfBssiList == sizeof(U32))
   1053     {
   1054         /* means that bssidList is empty*/
   1055         bssidList->NumberOfItems = 0;
   1056         /* os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - size of list is %d, indicating empty list\n",
   1057                         sizeof(U32)); */
   1058     }
   1059     else
   1060     {
   1061         if (OK != CuOs_GetBssidList(pCuCmd->hCuWext, bssidList))
   1062         {
   1063             os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant get Bssid list\n");
   1064             os_MemoryFree(bssidList);
   1065             return;
   1066         }
   1067     }
   1068 
   1069     /* get currently connected bssid */
   1070     if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid))
   1071     {
   1072         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant get current BSSID\n");
   1073         os_MemoryFree(bssidList);
   1074         return;
   1075     }
   1076 
   1077     /* print the list to the terminal */
   1078     CuCmd_PrintBssidList(bssidList, FALSE, bssid);
   1079 
   1080     /* free the bssidList */
   1081     os_MemoryFree(bssidList);
   1082 
   1083 }
   1084 
   1085 VOID CuCmd_FullBssidList(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1086 {
   1087     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1088     U32 SizeOfBssiList=0;
   1089     OS_802_11_BSSID_LIST_EX* bssidList;
   1090     TMacAddr bssid;
   1091 
   1092     if(OK != CuCommon_Get_BssidList_Size(pCuCmd->hCuCommon, &SizeOfBssiList)) return;
   1093 
   1094     /* allocate the bssidList */
   1095     bssidList = os_MemoryCAlloc(SizeOfBssiList, sizeof(U8));
   1096     if(bssidList == NULL)
   1097     {
   1098         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant allocate Bssid list\n");
   1099         return;
   1100     }
   1101 
   1102     if(SizeOfBssiList == sizeof(U32))
   1103     {
   1104         /* means that bssidList is empty*/
   1105         bssidList->NumberOfItems = 0;
   1106 
   1107     }
   1108     else
   1109     {
   1110         if(OK != CuOs_GetBssidList(pCuCmd->hCuWext, bssidList) ) return;
   1111     }
   1112 
   1113     /* get currently connected bssid */
   1114     if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid)) return;
   1115 
   1116     /* print the list to the terminal */
   1117     CuCmd_PrintBssidList(bssidList, TRUE, bssid);
   1118 
   1119     /* free the bssidList */
   1120     os_MemoryFree(bssidList);
   1121 }
   1122 
   1123 #if defined(CONFIG_WPS) && !defined(NO_WPA_SUPPL)
   1124 VOID CuCmd_StartEnrolleePIN(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1125 {
   1126     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1127 
   1128     if (pCuCmd->hWpaCore == NULL)
   1129     {
   1130         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot start Enrollee without connection to supplicant\n");
   1131         return;
   1132     }
   1133 
   1134     WpaCore_StartWpsPIN(pCuCmd->hWpaCore);
   1135     os_error_printf(CU_MSG_INFO2, (PS8)"WPS in PIN mode started\n");
   1136 }
   1137 
   1138 VOID CuCmd_StartEnrolleePBC(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1139 {
   1140     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1141 
   1142     if (pCuCmd->hWpaCore == NULL)
   1143     {
   1144         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot start Enrollee push button without connection to supplicant\n");
   1145         return;
   1146     }
   1147 
   1148     WpaCore_StartWpsPBC(pCuCmd->hWpaCore);
   1149     os_error_printf(CU_MSG_INFO2, (PS8)"WPS in PBC mode started\n");
   1150 }
   1151 
   1152 VOID CuCmd_StopEnrollee(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1153 {
   1154     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1155     if (pCuCmd->hWpaCore == NULL)
   1156     {
   1157         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot Stop Enrollee without connection to supplicant\n");
   1158         return;
   1159     }
   1160 
   1161     WpaCore_StopWps(pCuCmd->hWpaCore);
   1162     os_error_printf(CU_MSG_INFO2, (PS8)"WPS mode stopped\n");
   1163 }
   1164 
   1165 VOID CuCmd_SetPin(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1166 {
   1167     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1168 
   1169     if (pCuCmd->hWpaCore == NULL)
   1170     {
   1171         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot set PIN without connection to supplicant\n");
   1172         return;
   1173     }
   1174 
   1175     WpaCore_SetPin(pCuCmd->hWpaCore, (PS8)parm[0].value);
   1176     os_error_printf(CU_MSG_INFO2, (PS8)"WPS PIN set %s\n", parm[0].value);
   1177 }
   1178 
   1179 #endif /* CONFIG_WPS */
   1180 
   1181 VOID CuCmd_Connect(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1182 {
   1183     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1184     TMacAddr bssid = { 0xff,0xff,0xff,0xff,0xff,0xff };
   1185     OS_802_11_SSID ssid;
   1186     U32 BssType;
   1187 
   1188     switch (nParms)
   1189     {
   1190         case 0 :
   1191             /*
   1192             *  No SSID & No BSSID are set -
   1193             *  Use Any SSID & Any BSSID.
   1194             */
   1195             ssid.SsidLength = 0;
   1196             ssid.Ssid[0] = 0;
   1197             break;
   1198         case 1:
   1199             /*
   1200             *  SSID set & BSSID insn't set  -
   1201             *  Use CLI's SSID & Any BSSID.
   1202             */
   1203             ssid.SsidLength = os_strlen( (PS8)parm[0].value);
   1204             os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[0].value, ssid.SsidLength);
   1205             ssid.Ssid[ssid.SsidLength] = '\0';
   1206             break;
   1207         case 2:
   1208             /*
   1209              *  Both SSID & BSSID are set -
   1210              *  Use CLI's SSID & BSSID.
   1211              */
   1212             if(!CuCmd_Str2MACAddr( (PS8)parm[1].value, bssid) )
   1213                 return;
   1214             ssid.SsidLength = os_strlen((PS8) parm[0].value);
   1215             os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[0].value, ssid.SsidLength);
   1216             ssid.Ssid[ssid.SsidLength] = '\0';
   1217             break;
   1218     }
   1219 
   1220     if(pCuCmd->hWpaCore == NULL)
   1221     {
   1222         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, &BssType)) return;
   1223 
   1224         if((BssType == os802_11IBSS/* Ad-Hoc */) && (ssid.SsidLength == 0))
   1225         {
   1226             os_error_printf(CU_MSG_INFO2, (PS8)"SSID string is needed due to fact that BSS Type set to Ad-Hoc.\n");
   1227             return;
   1228         }
   1229 
   1230         if(OK != CuOs_Set_BSSID(pCuCmd->hCuWext, bssid ) ) return;
   1231         if(OK != CuOs_Set_ESSID(pCuCmd->hCuWext, &ssid) ) return;
   1232     }
   1233     else
   1234     {
   1235 #ifndef NO_WPA_SUPPL
   1236         if(OK != WpaCore_GetBssType(pCuCmd->hWpaCore, &BssType)) return;
   1237 
   1238         if((BssType == os802_11IBSS/* Ad-Hoc */) && (ssid.SsidLength == 0))
   1239         {
   1240             os_error_printf(CU_MSG_INFO2, (PS8)"SSID string is needed due to fact BSS Type set to Ad-Hoc\n");
   1241             return;
   1242         }
   1243 
   1244         WpaCore_SetSsid(pCuCmd->hWpaCore, &ssid, bssid);
   1245 #endif
   1246     }
   1247 }
   1248 
   1249 VOID CuCmd_Disassociate(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1250 {
   1251     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1252 
   1253     if(pCuCmd->hWpaCore == NULL)
   1254     {
   1255         OS_802_11_SSID ssid;
   1256 
   1257         ssid.SsidLength = MAX_SSID_LEN;
   1258         os_memset(ssid.Ssid, 0, MAX_SSID_LEN);
   1259 
   1260         CuOs_Set_ESSID(pCuCmd->hCuWext, &ssid);
   1261     }
   1262     else
   1263     {
   1264 #ifndef NO_WPA_SUPPL
   1265         WpaCore_Disassociate(pCuCmd->hWpaCore);
   1266 #endif
   1267     }
   1268 }
   1269 
   1270 VOID CuCmd_ModifySsid(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1271 {
   1272     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1273     OS_802_11_SSID ssid;
   1274     TMacAddr bssid = { 0xff,0xff,0xff,0xff,0xff,0xff };
   1275 
   1276     if( nParms == 0 )
   1277     {
   1278         OS_802_11_SSID ssid;
   1279         if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return;
   1280         os_error_printf(CU_MSG_INFO2, (PS8)"SSID: %s\n",(ssid.SsidLength)?(PS8)PrintSSID(&ssid):(PS8)"<empty>");
   1281     }
   1282     else
   1283     {
   1284         /* Setting the new SSID, BRCS BSSID is set to clean pre-set BSSID */
   1285         ssid.SsidLength = os_strlen((PS8) parm[0].value);
   1286         os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[0].value, ssid.SsidLength);
   1287         if(ssid.SsidLength < MAX_SSID_LEN)
   1288         {
   1289             ssid.Ssid[ssid.SsidLength] = 0;
   1290         }
   1291 
   1292         if(OK != CuOs_Set_BSSID(pCuCmd->hCuWext, bssid ) ) return;
   1293         if(OK != CuOs_Set_ESSID(pCuCmd->hCuWext, &ssid) ) return;
   1294     }
   1295 }
   1296 
   1297 VOID CuCmd_ModifyConnectMode(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1298 {
   1299     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1300     U32      i;
   1301 
   1302     if( nParms == 0 )
   1303     {
   1304         U32 uConnectMode;
   1305 
   1306         if(OK != CuCommon_GetU32 (pCuCmd->hCuCommon, SME_CONNECTION_MODE_PARAM, &uConnectMode)) return;
   1307         CU_CMD_FIND_NAME_ARRAY (i, Current_mode, uConnectMode);
   1308         os_error_printf (CU_MSG_INFO2, (PS8)"Current mode = %s\n", Current_mode[i].name);
   1309         print_available_values (Current_mode);
   1310     }
   1311     else
   1312     {
   1313         U32 uConnectMode = parm[0].value;
   1314 
   1315         /* check if the param is valid */
   1316         CU_CMD_FIND_NAME_ARRAY (i, Current_mode, uConnectMode);
   1317         if(i == SIZE_ARR(Current_mode))
   1318         {
   1319             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyConnectMode, Connect Mode %d is not defined!\n", uConnectMode);
   1320             print_available_values (Current_mode);
   1321             return;
   1322         }
   1323         else
   1324         {
   1325             CuCommon_SetU32(pCuCmd->hCuCommon, SME_CONNECTION_MODE_PARAM, uConnectMode);
   1326         }
   1327     }
   1328 }
   1329 
   1330 VOID CuCmd_ModifyChannel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1331 {
   1332     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1333 
   1334     if( nParms == 0 )
   1335     {
   1336         U8 desiredChannel = 0;
   1337         U32 currentChannel = 0;
   1338 
   1339 
   1340         if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, SITE_MGR_DESIRED_CHANNEL_PARAM, &desiredChannel)) return;
   1341         if(OK != CuOs_GetCurrentChannel(pCuCmd->hCuWext, &currentChannel)) return;
   1342 
   1343         os_error_printf(CU_MSG_INFO2, (PS8)"Channel=%d (desired: %d)\n",currentChannel,desiredChannel);
   1344     }
   1345     else
   1346     {
   1347         CuCommon_SetU32(pCuCmd->hCuCommon, SITE_MGR_DESIRED_CHANNEL_PARAM, parm[0].value);
   1348     }
   1349 }
   1350 
   1351 VOID CuCmd_GetTxRate(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1352 {
   1353     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1354 
   1355     if( nParms == 0)
   1356     {
   1357         U8 CurrentTxRate;
   1358         S8 CurrentTxRateStr[50];
   1359 
   1360         if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_CURRENT_RATES_GET, &CurrentTxRate)) return;
   1361 
   1362         CuCmd_CreateRateStr(CurrentTxRateStr, CurrentTxRate);
   1363         os_error_printf(CU_MSG_INFO2, (PS8)"Rate: %s\n", CurrentTxRateStr);
   1364     }
   1365 }
   1366 
   1367 VOID CuCmd_ModifyBssType(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1368 {
   1369     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1370     U32 BssType = 0;
   1371     S32 i;
   1372 
   1373     if( nParms == 0 )
   1374     {
   1375         if(pCuCmd->hWpaCore == NULL)
   1376         {
   1377             if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, &BssType)) return;
   1378         }
   1379         else
   1380         {
   1381 #ifndef NO_WPA_SUPPL
   1382             if(OK != WpaCore_GetBssType(pCuCmd->hWpaCore, &BssType)) return;
   1383 #endif
   1384         }
   1385 
   1386         CU_CMD_FIND_NAME_ARRAY(i, BSS_type, BssType);
   1387         if(i == SIZE_ARR(BSS_type))
   1388         {
   1389             os_error_printf(CU_MSG_INFO2, (PS8)"Error getting the current BssType! BssType=0x%x\n",BssType);
   1390             return;
   1391         }
   1392         else
   1393         {
   1394             os_error_printf(CU_MSG_INFO2, (PS8)"Current mode = %s\n", BSS_type[i].name);
   1395         }
   1396         print_available_values(BSS_type);
   1397     }
   1398     else
   1399     {
   1400         BssType = parm[0].value;
   1401         /* check if the param is valid */
   1402         CU_CMD_FIND_NAME_ARRAY(i, BSS_type, BssType);
   1403         if(i == SIZE_ARR(BSS_type))
   1404         {
   1405             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyBssType, BssType %d is not defined!\n", BssType);
   1406             return;
   1407         }
   1408         if(pCuCmd->hWpaCore == NULL)
   1409         {
   1410             CuCommon_SetU32(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, BssType);
   1411             CuCommon_SetU32(pCuCmd->hCuCommon, SME_DESIRED_BSS_TYPE_PARAM, BssType);
   1412         }
   1413         else
   1414         {
   1415 #ifndef NO_WPA_SUPPL
   1416             WpaCore_SetBssType(pCuCmd->hWpaCore, BssType);
   1417 #endif
   1418         }
   1419     }
   1420 }
   1421 
   1422 VOID CuCmd_ModifyFragTh(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1423 {
   1424     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1425     S32 FragTh;
   1426 
   1427     if( nParms == 0 )
   1428     {
   1429         if(OK != CuOs_GetFragTh(pCuCmd->hCuWext, &FragTh)) return;
   1430         os_error_printf(CU_MSG_INFO2, (PS8)"Frag. threshold = %d\n", FragTh);
   1431     }
   1432     else
   1433     {
   1434         FragTh = parm[0].value;
   1435         CuOs_SetFragTh(pCuCmd->hCuWext, FragTh);
   1436     }
   1437 }
   1438 
   1439 VOID CuCmd_ModifyRtsTh(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1440 {
   1441     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1442     S32 RtsTh;
   1443 
   1444     if( nParms == 0 )
   1445     {
   1446         if(OK != CuOs_GetRtsTh(pCuCmd->hCuWext, &RtsTh)) return;
   1447         os_error_printf(CU_MSG_INFO2, (PS8)"RTS threshold = %d\n", RtsTh);
   1448     }
   1449     else
   1450     {
   1451         RtsTh = parm[0].value;
   1452         CuOs_SetRtsTh(pCuCmd->hCuWext, RtsTh);
   1453     }
   1454 }
   1455 
   1456 VOID CuCmd_ModifyPreamble(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1457 {
   1458     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1459     EPreamble Preamble;
   1460     S32 i;
   1461     named_value_t preamble_type[] = {
   1462         { PREAMBLE_LONG,              (PS8)"PREAMBLE_LONG" },
   1463         { PREAMBLE_SHORT,             (PS8)"PREAMBLE_SHORT" }
   1464     };
   1465 
   1466     if(nParms)
   1467     {
   1468         Preamble = parm[0].value;
   1469         /* check if the param is valid */
   1470         CU_CMD_FIND_NAME_ARRAY(i, preamble_type, Preamble);
   1471         if(i == SIZE_ARR(preamble_type))
   1472         {
   1473             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyPreamble, Preamble %d is not defined!\n", Preamble);
   1474             return;
   1475         }
   1476         CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_SET, Preamble);
   1477     }
   1478     else
   1479     {
   1480         S32 PreambleData;
   1481         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_GET, (PU32)&PreambleData)) return;
   1482         Preamble = PreambleData;
   1483         os_error_printf(CU_MSG_INFO2, (PS8)"Preamble = %d\n", Preamble);
   1484         print_available_values(preamble_type);
   1485     }
   1486 }
   1487 
   1488 VOID CuCmd_ModifyShortSlot(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1489 {
   1490     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1491     slotTime_e SlotTime;
   1492     S32 i;
   1493     named_value_t SlotTime_type[] = {
   1494         { PHY_SLOT_TIME_LONG,              (PS8)"PHY_SLOT_TIME_LONG" },
   1495         { PHY_SLOT_TIME_SHORT,             (PS8)"PHY_SLOT_TIME_SHORT" }
   1496     };
   1497 
   1498     if(nParms)
   1499     {
   1500         SlotTime = parm[0].value;
   1501         /* check if the param is valid */
   1502         CU_CMD_FIND_NAME_ARRAY(i, SlotTime_type, SlotTime);
   1503         if(i == SIZE_ARR(SlotTime_type))
   1504         {
   1505             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyShortSlot, SlotTime %d is not defined!\n", SlotTime);
   1506             return;
   1507         }
   1508         CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_SHORT_SLOT_SET, SlotTime);
   1509     }
   1510     else
   1511     {
   1512         S32 SlotTimeData;
   1513         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_SHORT_SLOT_GET, (PU32)&SlotTimeData)) return;
   1514         SlotTime = SlotTimeData;
   1515         os_error_printf(CU_MSG_INFO2, (PS8)"SlotTime = %d\n", SlotTime);
   1516         print_available_values(SlotTime_type);
   1517     }
   1518 }
   1519 
   1520 
   1521 VOID CuCmd_RadioOnOff(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1522 {
   1523 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1524 	U32      on_off;
   1525 
   1526 	if(nParms)
   1527     {
   1528 		on_off = parm[0].value;
   1529 		CuCommon_SetU32(pCuCmd->hCuCommon, SME_RADIO_ON_PARAM, on_off);
   1530 	}
   1531 	else
   1532     {
   1533 		if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, SME_RADIO_ON_PARAM, &on_off)) {
   1534 			os_error_printf(CU_MSG_ERROR, (PS8)"CuCmd_RadioOnOff error, Cannot get radio state!\n");
   1535 			return;
   1536 	}
   1537 		os_error_printf(CU_MSG_ERROR, (PS8)"Radio state = %s\n", on_off ? "ON" : "OFF");
   1538         os_error_printf(CU_MSG_ERROR, (PS8)"Turn radio on/off. 0=OFF, 1=ON\n");
   1539 	}
   1540 }
   1541 
   1542 
   1543 VOID CuCmd_GetSelectedBssidInfo(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1544 {
   1545     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1546     OS_802_11_SSID ssid;
   1547     TMacAddr bssid;
   1548 
   1549     if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return;
   1550     if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid)) return;
   1551 
   1552     os_error_printf(CU_MSG_INFO2, (PS8)"Selected BSSID Info:\n");
   1553     os_error_printf(CU_MSG_INFO2, (PS8)"--------------------\n");
   1554     os_error_printf(CU_MSG_INFO2, (PS8)"SSID : %s\n",(ssid.SsidLength)?(PS8)PrintSSID(&ssid):(PS8)"<empty>");
   1555     os_error_printf(CU_MSG_INFO2, (PS8)"BSSID : %02x.%02x.%02x.%02x.%02x.%02x\n",bssid[0],bssid[1],bssid[2],bssid[3],bssid[4],bssid[5]);
   1556 }
   1557 
   1558 VOID CuCmd_GetRsiiLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1559 {
   1560     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1561     S8 dRssi, bRssi;
   1562 
   1563     if(OK != CuCommon_GetRssi(pCuCmd->hCuCommon, &dRssi, &bRssi)) return;
   1564 	/* need the 0xffffff00 to get negative value display */
   1565     os_error_printf(CU_MSG_INFO2, (PS8)"Current dataRSSI=%d  beaconRssi=%d\n", dRssi?dRssi|0xffffff00:dRssi, bRssi?bRssi|0xffffff00:bRssi);
   1566 }
   1567 
   1568 VOID CuCmd_GetSnrRatio(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1569 {
   1570     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1571     U32 dSnr, bSnr;
   1572 
   1573     if(OK != CuCommon_GetSnr(pCuCmd->hCuCommon, &dSnr, &bSnr)) return;
   1574     os_error_printf(CU_MSG_INFO2, (PS8)"Current dataSNR=%d   beaconSnr=%d\n", dSnr, bSnr);
   1575 }
   1576 
   1577 VOID CuCmd_ShowTxPowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1578 {
   1579     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1580 
   1581     S32 txPowerLevel;
   1582     if(OK != CuOs_GetTxPowerLevel(pCuCmd->hCuWext, &txPowerLevel)) return;
   1583 
   1584     os_error_printf(CU_MSG_INFO2, (PS8)"Tx Power level = %d\n", txPowerLevel);
   1585 }
   1586 
   1587 VOID CuCmd_ShowTxPowerTable(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1588 {
   1589     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1590     TpowerLevelTable_t txPowerLevel;
   1591     S32 i, res;
   1592 
   1593     res = CuCommon_GetBuffer(pCuCmd->hCuCommon, REGULATORY_DOMAIN_TX_POWER_LEVEL_TABLE_PARAM, &txPowerLevel, sizeof(txPowerLevel));
   1594 
   1595     if( !res )
   1596     {
   1597         os_error_printf(CU_MSG_INFO2, (PS8)"Power level table (Dbm/10)\n");
   1598         for (i = 0; i < NUMBER_OF_SUB_BANDS_E; i++)
   1599         {
   1600             os_error_printf(CU_MSG_INFO2, (PS8)"sub-band %i: %d %d %d %d\n", i,
   1601             txPowerLevel.uDbm[i][0],
   1602             txPowerLevel.uDbm[i][1],
   1603             txPowerLevel.uDbm[i][2],
   1604             txPowerLevel.uDbm[i][3]);
   1605         }
   1606     }
   1607     else
   1608     {
   1609         os_error_printf(CU_MSG_INFO2, (PS8)"Tx Power level table ERROR !!!\n");
   1610     }
   1611 }
   1612 
   1613 VOID CuCmd_TxPowerDbm(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1614 {
   1615     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1616     U8 txPowerLevelDbm = (U8)parm[0].value;
   1617 
   1618     if(nParms == 0)
   1619     {
   1620         if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_TX_POWER_DBM_GET, (PU8)&txPowerLevelDbm)) return;
   1621     }
   1622     else
   1623     {
   1624         if (parm[0].value > MAX_TX_POWER)
   1625         {
   1626             os_error_printf(CU_MSG_INFO2, (PS8)"Please use values between %d and %d\n", MIN_TX_POWER, MAX_TX_POWER); return;
   1627         }
   1628         else
   1629 		{
   1630 			if(OK != CuCommon_SetU8(pCuCmd->hCuCommon, TIWLN_802_11_TX_POWER_DBM_GET, (U8)txPowerLevelDbm)) return;
   1631 		}
   1632     }
   1633 
   1634     os_error_printf(CU_MSG_INFO2, (PS8)"Tx Power in DBM = %d\n", txPowerLevelDbm);
   1635 }
   1636 
   1637 VOID CuCmd_ModifyState_802_11d(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1638 {
   1639     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1640     U32 Enabled_802_11d;
   1641 
   1642     if(nParms == 0)
   1643     {
   1644         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_802_11D, &Enabled_802_11d)) return;
   1645         os_error_printf(CU_MSG_INFO2, (PS8)"802_11d enabled = %s\n", (Enabled_802_11d)?"TRUE":"FALSE");
   1646     }
   1647     else
   1648     {
   1649         Enabled_802_11d = parm[0].value;
   1650         if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_ENABLE_DISABLE_802_11D, Enabled_802_11d))
   1651         {
   1652             U32 Enabled_802_11h;
   1653             if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_802_11H, &Enabled_802_11h)) return;
   1654             if(Enabled_802_11h && (!Enabled_802_11d))
   1655                 os_error_printf(CU_MSG_INFO2, (PS8)"802_11d cannot be disabled while 802_11h is enabled!!\n" );
   1656 
   1657         }
   1658         else
   1659         {
   1660             os_error_printf(CU_MSG_INFO2, (PS8)"802_11d status is updated to = %s\n", (Enabled_802_11d)?"TRUE":"FALSE" );
   1661         }
   1662     }
   1663 }
   1664 
   1665 VOID CuCmd_ModifyState_802_11h(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1666 {
   1667     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1668     U32 Enabled_802_11h;
   1669 
   1670     if(nParms == 0)
   1671     {
   1672         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_802_11H, &Enabled_802_11h)) return;
   1673         os_error_printf(CU_MSG_INFO2, (PS8)"802_11h enabled = %s\n", (Enabled_802_11h)?"TRUE":"FALSE");
   1674     }
   1675     else
   1676     {
   1677         Enabled_802_11h = parm[0].value;
   1678         if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_ENABLE_DISABLE_802_11H, Enabled_802_11h)) return;
   1679         if(Enabled_802_11h)
   1680             os_error_printf(CU_MSG_INFO2, (PS8)"802_11h enables automatically 802_11d!!\n" );
   1681 
   1682         os_error_printf(CU_MSG_INFO2, (PS8)"802_11h status is updated to =%d\n", Enabled_802_11h );
   1683     }
   1684 }
   1685 
   1686 VOID CuCmd_D_Country_2_4Ie(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1687 {
   1688     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1689 
   1690     if( nParms == 0 )
   1691     {
   1692         U8   CountryString[DOT11_COUNTRY_STRING_LEN+1];
   1693         if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_COUNTRY_2_4,
   1694             CountryString, DOT11_COUNTRY_STRING_LEN+1)) return;
   1695         CountryString[DOT11_COUNTRY_STRING_LEN] = '\0';
   1696         if (CountryString[0] == '\0')
   1697         {
   1698             os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 2.4 GHz is not found\n");
   1699         }
   1700         else
   1701         {
   1702             os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 2.4 GHz is %s \n", CountryString );
   1703         }
   1704     }
   1705     else
   1706     {
   1707         country_t CountryWorld;
   1708 
   1709         CountryWorld.elementId = COUNTRY_IE_ID;
   1710         CountryWorld.len = 6;
   1711         os_memcpy( (PVOID)CountryWorld.countryIE.CountryString,(PVOID)"GB ", 3);
   1712         CountryWorld.countryIE.tripletChannels[0].firstChannelNumber = 1;
   1713         CountryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 23;
   1714         CountryWorld.countryIE.tripletChannels[0].numberOfChannels = 11;
   1715 
   1716         if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_SET_COUNTRY_2_4,
   1717             &CountryWorld, sizeof(country_t))) return;
   1718 
   1719         os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Start Setting GB Country for 2.4 GHz\n");
   1720     }
   1721 }
   1722 
   1723 
   1724 VOID CuCmd_D_Country_5Ie(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1725 {
   1726     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1727 
   1728     if( nParms == 0 )
   1729     {
   1730         U8   CountryString[DOT11_COUNTRY_STRING_LEN+1];
   1731 
   1732         if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_COUNTRY_5,
   1733             CountryString, DOT11_COUNTRY_STRING_LEN+1)) return;
   1734 
   1735         CountryString[DOT11_COUNTRY_STRING_LEN] = '\0';
   1736         if (CountryString[0] == '\0')
   1737         {
   1738             os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 5 GHz is not found\n");
   1739         }
   1740         else
   1741         {
   1742             os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 5 GHz is %s\n", CountryString );
   1743         }
   1744     }
   1745     else
   1746     {
   1747         country_t CountryWorld;
   1748 
   1749         CountryWorld.elementId = COUNTRY_IE_ID;
   1750         CountryWorld.len = 6;
   1751         os_memcpy((PVOID) CountryWorld.countryIE.CountryString,(PVOID)"US ", 3);
   1752         CountryWorld.countryIE.tripletChannels[0].firstChannelNumber = 36;
   1753         CountryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 13;
   1754         CountryWorld.countryIE.tripletChannels[0].numberOfChannels = 8;
   1755 
   1756         if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_SET_COUNTRY_5,
   1757             &CountryWorld, sizeof(country_t))) return;
   1758 
   1759         os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Start Setting US Country for 5 GHz\n");
   1760     }
   1761 }
   1762 
   1763 VOID CuCmd_ModifyDfsRange(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1764 {
   1765     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1766     U16 minDFS_channelNum;
   1767     U16 maxDFS_channelNum;
   1768 
   1769     if( nParms == 0 )
   1770     {
   1771         if(OK != CuCommon_GetDfsChannels(pCuCmd->hCuCommon, &minDFS_channelNum, &maxDFS_channelNum)) return;
   1772 
   1773         os_error_printf(CU_MSG_INFO2, (PS8)"DFS min channel is %d, DFS max channel is %d\n",
   1774                                     minDFS_channelNum, maxDFS_channelNum);
   1775     }
   1776     else
   1777     {
   1778         minDFS_channelNum = (U16) parm[0].value;
   1779         maxDFS_channelNum = (U16) parm[1].value;
   1780 
   1781         if(OK != CuCommon_SetDfsChannels(pCuCmd->hCuCommon, minDFS_channelNum, maxDFS_channelNum)) return;
   1782 
   1783         os_error_printf(CU_MSG_INFO2, (PS8)"Setting DFS min channel %d, DFS max channel %d\n",
   1784                                     minDFS_channelNum, maxDFS_channelNum);
   1785     }
   1786 }
   1787 
   1788 VOID CuCmd_SetBeaconFilterDesiredState(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1789 {
   1790     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1791 
   1792     if( nParms == 0 )
   1793     {
   1794         print_available_values(BeaconFilter_use);
   1795     }
   1796     else
   1797     {
   1798         CuCommon_SetU8(pCuCmd->hCuCommon, TIWLN_802_11_BEACON_FILTER_DESIRED_STATE_SET, (U8)parm[0].value);
   1799     }
   1800 }
   1801 
   1802 VOID CuCmd_GetBeaconFilterDesiredState(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1803 {
   1804     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1805     U8 beaconFilterDesiredState = 0;
   1806 
   1807     if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_BEACON_FILTER_DESIRED_STATE_GET, &beaconFilterDesiredState)) return;
   1808 
   1809     os_error_printf(CU_MSG_INFO2, (PS8)"Desired State is %s\n", (beaconFilterDesiredState == 0)?"FILTER INACTIVE":"FILTER ACTIVE" );
   1810 }
   1811 
   1812 VOID CuCmd_ModifySupportedRates(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1813 {
   1814     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1815     rates_t SupportedRates;
   1816     S32 i;
   1817 
   1818     if( nParms == 0 )
   1819     {
   1820         if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SUPPORTED_RATES,
   1821             &SupportedRates, sizeof(rates_t))) return;
   1822 
   1823         os_error_printf(CU_MSG_INFO2, (PS8)" Rates: ");
   1824         for( i=0; i < SupportedRates.len; i++ )
   1825         {
   1826             os_error_printf(CU_MSG_INFO2,
   1827                             (PS8)"%g Mbps(%u%s)%s",
   1828                             /* patch in order to support NET_RATE_MCS7 values that equal to NET_RATE_1M_BASIC */
   1829                             (RATE_2_MBPS(SupportedRates.ratesString[i]) == 63.5) ? 65 : RATE_2_MBPS(SupportedRates.ratesString[i]),
   1830                             /* patch in order to support NET_RATE_MCS7 values that equal to NET_RATE_1M_BASIC */
   1831                             (SupportedRates.ratesString[i] == 0x7f) ? 0x83 : SupportedRates.ratesString[i],
   1832                 IS_BASIC_RATE(SupportedRates.ratesString[i]) ? " - basic" : "",
   1833                 (i < SupportedRates.len-1) ? "," : "" );
   1834         }
   1835         os_error_printf(CU_MSG_INFO2, (PS8)"\n");
   1836     }
   1837     else
   1838     {
   1839         PS8 buf = (PS8) parm[0].value;
   1840         PS8 end_p;
   1841         U32 val;
   1842         U32 MaxVal = ((1 << (sizeof(SupportedRates.ratesString[i]) * 8))-1);
   1843 
   1844         os_error_printf(CU_MSG_INFO2, (PS8)"param: %s\n", buf );
   1845 
   1846         for( i=0; *buf && i < DOT11_MAX_SUPPORTED_RATES; i++ )
   1847         {
   1848             val = os_strtoul(buf, &end_p, 0);
   1849             if(val == 0)
   1850             {
   1851                 os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifySupportedRates: invalid value - %s\n", buf );
   1852                 return;
   1853             }
   1854             if(val > MaxVal)
   1855             {
   1856                 os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifySupportedRates: out of range %d\n", val );
   1857                 return;
   1858             }
   1859             /* patch in order to support NET_RATE_MCS7 values that equal to NET_RATE_1M_BASIC */
   1860             if (val == 0x83)
   1861             {
   1862                 val = 0x7f;
   1863             }
   1864             SupportedRates.ratesString[i] = (U8)(val);
   1865             buf = end_p;
   1866             while( *buf==' ' || *buf == ',' )   buf++;
   1867         }
   1868         if(*buf)
   1869         {
   1870             os_error_printf(CU_MSG_INFO2, (PS8)"too many parameters. Max=%d\n", DOT11_MAX_SUPPORTED_RATES );
   1871             return;
   1872         }
   1873 
   1874         SupportedRates.len = (U8) i;
   1875         CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SUPPORTED_RATES,
   1876             &SupportedRates, sizeof(rates_t));
   1877     }
   1878 }
   1879 
   1880 VOID CuCmd_SendHealthCheck(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1881 {
   1882     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1883 
   1884     if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, HEALTH_MONITOR_CHECK_DEVICE, TRUE)) return;
   1885 
   1886     os_error_printf(CU_MSG_INFO2, (PS8)"Send health check...\n");
   1887 }
   1888 
   1889 VOID CuCmd_EnableRxDataFilters(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1890 {
   1891     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1892 
   1893     if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_ENABLE_DISABLE_RX_DATA_FILTERS, TRUE)) return;
   1894 
   1895     os_error_printf(CU_MSG_INFO2, (PS8)"Enabling Rx data filtering...\n");
   1896 }
   1897 
   1898 VOID CuCmd_DisableRxDataFilters(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1899 {
   1900     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1901 
   1902     if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_ENABLE_DISABLE_RX_DATA_FILTERS, FALSE)) return;
   1903 
   1904     os_error_printf(CU_MSG_INFO2, (PS8)"Disabling Rx data filtering...\n");
   1905 }
   1906 
   1907 VOID CuCmd_AddRxDataFilter(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1908 {
   1909     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1910     S32 res;
   1911     TRxDataFilterRequest request;
   1912     PS8 mask = (PS8) parm[1].value;
   1913     PS8 pattern = (PS8) parm[2].value;
   1914 
   1915     request.offset = (U8)parm[0].value;
   1916     CuCmd_ParseMaskString(mask, request.mask, &request.maskLength);
   1917     CuCmd_ParsePatternString(pattern, request.pattern, &request.patternLength);
   1918 
   1919     res = CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_ADD_RX_DATA_FILTER,
   1920         &request, sizeof(TRxDataFilterRequest));
   1921 
   1922     if(res == OK)
   1923         os_error_printf(CU_MSG_INFO2, (PS8)"Filter added.\n");
   1924     else
   1925         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddRxDataFilter - Couldn't add Rx data filter...\n");
   1926 
   1927 }
   1928 
   1929 VOID CuCmd_RemoveRxDataFilter(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1930 {
   1931     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1932     S32 res;
   1933     TRxDataFilterRequest request;
   1934     PS8 mask = (PS8) parm[1].value;
   1935     PS8 pattern = (PS8) parm[2].value;
   1936 
   1937     request.offset = (U8)parm[0].value;
   1938     CuCmd_ParseMaskString(mask, request.mask, &request.maskLength);
   1939     CuCmd_ParsePatternString(pattern, request.pattern, &request.patternLength);
   1940 
   1941     res = CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REMOVE_RX_DATA_FILTER,
   1942         &request, sizeof(TRxDataFilterRequest));
   1943 
   1944     if(res == OK)
   1945         os_error_printf(CU_MSG_INFO2, (PS8)"Filter Removed.\n");
   1946     else
   1947         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddRxDataFilter - Couldn't remove Rx data filter...\n");
   1948 }
   1949 
   1950 VOID CuCmd_GetRxDataFiltersStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1951 {
   1952     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1953     U32 UnmatchedPacketsCount;
   1954     U32 MatchedPacketsCount[4];
   1955 
   1956     if (OK != CuCommon_GetRxDataFiltersStatistics(pCuCmd->hCuCommon, &UnmatchedPacketsCount, MatchedPacketsCount)) return;
   1957 
   1958     os_error_printf(CU_MSG_INFO2, (PS8)"Rx data filtering statistics:\n");
   1959     os_error_printf(CU_MSG_INFO2, (PS8)"Unmatched packets: %u\n", UnmatchedPacketsCount);
   1960     os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #1: %u\n", MatchedPacketsCount[0]);
   1961     os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #2: %u\n", MatchedPacketsCount[1]);
   1962     os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #3: %u\n", MatchedPacketsCount[2]);
   1963     os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #4: %u\n", MatchedPacketsCount[3]);
   1964 }
   1965 
   1966 VOID CuCmd_ShowStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   1967 {
   1968     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   1969 
   1970     U32 powerMode;
   1971     TMacAddr Mac;
   1972     OS_802_11_SSID ssid;
   1973     U8 desiredChannel;
   1974     S32 rtsTh;
   1975     S32 fragTh;
   1976     S32 txPowerLevel;
   1977     U8 bssType;
   1978     U32 desiredPreambleType;
   1979     TIWLN_COUNTERS driverCounters;
   1980     U32 AuthMode;
   1981     U8  CurrentTxRate;
   1982     S8  CurrentTxRateStr[20];
   1983     U8  CurrentRxRate;
   1984     S8  CurrentRxRateStr[20];
   1985     U32 DefaultKeyId;
   1986     U32 WepStatus;
   1987     S8 dRssi, bRssi;
   1988 #ifdef XCC_MODULE_INCLUDED
   1989     U32 XCCNetEap;
   1990 #endif
   1991 
   1992     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, CTRL_DATA_MAC_ADDRESS,
   1993             Mac, sizeof(TMacAddr))) return;
   1994     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET, &powerMode, sizeof(U32))) return;
   1995     if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return;
   1996     if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, SITE_MGR_DESIRED_CHANNEL_PARAM, &desiredChannel)) return;
   1997     if(OK != CuOs_GetRtsTh(pCuCmd->hCuWext, &rtsTh)) return;
   1998     if(OK != CuOs_GetFragTh(pCuCmd->hCuWext, &fragTh)) return;
   1999     if(OK != CuOs_GetTxPowerLevel(pCuCmd->hCuWext, &txPowerLevel)) return;
   2000     if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, &bssType)) return;
   2001     if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_GET, &desiredPreambleType)) return;
   2002     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, SITE_MGR_TI_WLAN_COUNTERS_PARAM, &driverCounters, sizeof(TIWLN_COUNTERS))) return;
   2003     if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_ENCRYPTION_STATUS_PARAM, &WepStatus)) return;
   2004     if(OK != CuCommon_GetRssi(pCuCmd->hCuCommon, &dRssi, &bRssi)) return;
   2005     if (pCuCmd->hWpaCore == NULL)
   2006     {
   2007         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, &AuthMode)) return;
   2008         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_DEFAULT_KEY_ID, &DefaultKeyId)) return;
   2009     }
   2010     else
   2011     {
   2012 #ifndef NO_WPA_SUPPL
   2013         if(OK != WpaCore_GetAuthMode(pCuCmd->hWpaCore, &AuthMode)) return;
   2014         if(OK != WpaCore_GetDefaultKey(pCuCmd->hWpaCore, &DefaultKeyId)) return;
   2015 #endif
   2016     }
   2017 
   2018     if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_CURRENT_RATES_GET, &CurrentTxRate)) return;
   2019     CuCmd_CreateRateStr(CurrentTxRateStr, CurrentTxRate);
   2020 
   2021     if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_GET_RX_DATA_RATE, &CurrentRxRate)) return;
   2022     CuCmd_CreateRateStr(CurrentRxRateStr, CurrentRxRate);
   2023 
   2024 #ifdef XCC_MODULE_INCLUDED
   2025     if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_XCC_NETWORK_EAP, &XCCNetEap)) return;
   2026 #endif
   2027 
   2028     os_error_printf(CU_MSG_INFO2, (PS8)"******************\n");
   2029     os_error_printf(CU_MSG_INFO2, (PS8)"Driver Statistics:\n");
   2030     os_error_printf(CU_MSG_INFO2, (PS8)"******************\n");
   2031 
   2032     os_error_printf(CU_MSG_INFO2, (PS8)"    dot11CurrentTxRate : %s\n", CurrentTxRateStr);
   2033 	os_error_printf(CU_MSG_INFO2, (PS8)"         CurrentRxRate : %s\n", CurrentRxRateStr);
   2034     os_error_printf(CU_MSG_INFO2, (PS8)"   dot11DesiredChannel : %d\n", desiredChannel);
   2035     os_error_printf(CU_MSG_INFO2, (PS8)"     currentMACAddress : %02x.%02x.%02x.%02x.%02x.%02x\n",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);
   2036     os_error_printf(CU_MSG_INFO2, (PS8)"      dot11DesiredSSID : %s\n", ssid.Ssid);
   2037     os_error_printf(CU_MSG_INFO2, (PS8)"          dot11BSSType : %d\n", bssType);
   2038     os_error_printf(CU_MSG_INFO2, (PS8)"    AuthenticationMode : %d\n", AuthMode );
   2039     os_error_printf(CU_MSG_INFO2, (PS8)"    bShortPreambleUsed : %d\n", desiredPreambleType );
   2040     os_error_printf(CU_MSG_INFO2, (PS8)"          RTSThreshold : %d\n", rtsTh );
   2041     os_error_printf(CU_MSG_INFO2, (PS8)"FragmentationThreshold : %d\n", fragTh );
   2042     os_error_printf(CU_MSG_INFO2, (PS8)" bDefaultWEPKeyDefined : %d\n", DefaultKeyId);
   2043     os_error_printf(CU_MSG_INFO2, (PS8)"             WEPStatus : %d\n", WepStatus);
   2044     os_error_printf(CU_MSG_INFO2, (PS8)"          TxPowerLevel : %d\n", txPowerLevel );
   2045     os_error_printf(CU_MSG_INFO2, (PS8)"             PowerMode : %d\n", powerMode );
   2046     os_error_printf(CU_MSG_INFO2, (PS8)"              dataRssi : %d\n", dRssi);
   2047 	os_error_printf(CU_MSG_INFO2, (PS8)"            beaconRssi : %d\n", bRssi);
   2048     /**/
   2049     /* network layer statistics*/
   2050     /**/
   2051     os_error_printf(CU_MSG_INFO2, (PS8)"                RecvOk : %d\n", driverCounters.RecvOk );
   2052     os_error_printf(CU_MSG_INFO2, (PS8)"             RecvError : %d\n", driverCounters.RecvError );
   2053     os_error_printf(CU_MSG_INFO2, (PS8)"     DirectedBytesRecv : %d\n", driverCounters.DirectedBytesRecv );
   2054     os_error_printf(CU_MSG_INFO2, (PS8)"    DirectedFramesRecv : %d\n", driverCounters.DirectedFramesRecv );
   2055     os_error_printf(CU_MSG_INFO2, (PS8)"    MulticastBytesRecv : %d\n", driverCounters.MulticastBytesRecv );
   2056     os_error_printf(CU_MSG_INFO2, (PS8)"   MulticastFramesRecv : %d\n", driverCounters.MulticastFramesRecv );
   2057     os_error_printf(CU_MSG_INFO2, (PS8)"    BroadcastBytesRecv : %d\n", driverCounters.BroadcastBytesRecv );
   2058     os_error_printf(CU_MSG_INFO2, (PS8)"   BroadcastFramesRecv : %d\n", driverCounters.BroadcastFramesRecv );
   2059     os_error_printf(CU_MSG_INFO2, (PS8)"             FcsErrors : %d\n", driverCounters.FcsErrors );
   2060     os_error_printf(CU_MSG_INFO2, (PS8)"           BeaconsRecv : %d\n", driverCounters.BeaconsRecv );
   2061     os_error_printf(CU_MSG_INFO2, (PS8)"          AssocRejects : %d\n", driverCounters.AssocRejects );
   2062     os_error_printf(CU_MSG_INFO2, (PS8)"         AssocTimeouts : %d\n", driverCounters.AssocTimeouts );
   2063     os_error_printf(CU_MSG_INFO2, (PS8)"           AuthRejects : %d\n", driverCounters.AuthRejects );
   2064     os_error_printf(CU_MSG_INFO2, (PS8)"          AuthTimeouts : %d\n", driverCounters.AuthTimeouts );
   2065 
   2066     /**/
   2067     /* other statistics*/
   2068     /**/
   2069 #ifdef XCC_MODULE_INCLUDED
   2070     os_error_printf(CU_MSG_INFO2, (PS8)"        dwSecuritySuit : %d\n", XCCNetEap);
   2071 #endif
   2072 }
   2073 
   2074 VOID CuCmd_ShowTxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2075 {
   2076     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2077     TIWLN_TX_STATISTICS txCounters;
   2078     U32 TxQid;
   2079     U32 AverageDelay;
   2080     U32 AverageFWDelay;
   2081     U32 AverageMacDelay;
   2082 
   2083     if( nParms == 0 )
   2084     {
   2085         if(OK != CuCommon_GetTxStatistics(pCuCmd->hCuCommon, &txCounters, 0)) return;
   2086     }
   2087     else
   2088     {
   2089         if(OK != CuCommon_GetTxStatistics(pCuCmd->hCuCommon, &txCounters, parm[0].value)) return;
   2090     }
   2091 
   2092     os_error_printf(CU_MSG_INFO2, (PS8)"*********************\n");
   2093     os_error_printf(CU_MSG_INFO2, (PS8)"Tx Queues Statistics:\n");
   2094     os_error_printf(CU_MSG_INFO2, (PS8)"*********************\n");
   2095 
   2096     for (TxQid = 0; TxQid < MAX_NUM_OF_AC; TxQid++)
   2097     {
   2098         os_error_printf(CU_MSG_INFO2, (PS8)"\nTx Queue %d:\n", TxQid);
   2099         os_error_printf(CU_MSG_INFO2, (PS8)"===========\n");
   2100 
   2101         os_error_printf(CU_MSG_INFO2, (PS8)"  Total Good Frames             : %d\n", txCounters.txCounters[TxQid].XmitOk );
   2102         os_error_printf(CU_MSG_INFO2, (PS8)"  Unicast Bytes                 : %d\n", txCounters.txCounters[TxQid].DirectedBytesXmit );
   2103         os_error_printf(CU_MSG_INFO2, (PS8)"  Unicast Frames                : %d\n", txCounters.txCounters[TxQid].DirectedFramesXmit );
   2104         os_error_printf(CU_MSG_INFO2, (PS8)"  Multicast Bytes               : %d\n", txCounters.txCounters[TxQid].MulticastBytesXmit );
   2105         os_error_printf(CU_MSG_INFO2, (PS8)"  Multicast Frames              : %d\n", txCounters.txCounters[TxQid].MulticastFramesXmit );
   2106         os_error_printf(CU_MSG_INFO2, (PS8)"  Broadcast Bytes               : %d\n", txCounters.txCounters[TxQid].BroadcastBytesXmit );
   2107         os_error_printf(CU_MSG_INFO2, (PS8)"  Broadcast Frames              : %d\n", txCounters.txCounters[TxQid].BroadcastFramesXmit );
   2108         os_error_printf(CU_MSG_INFO2, (PS8)"  Retry Failures                : %d\n", txCounters.txCounters[TxQid].RetryFailCounter );
   2109         os_error_printf(CU_MSG_INFO2, (PS8)"  Tx Timeout Failures           : %d\n", txCounters.txCounters[TxQid].TxTimeoutCounter );
   2110         os_error_printf(CU_MSG_INFO2, (PS8)"  No Link Failures              : %d\n", txCounters.txCounters[TxQid].NoLinkCounter );
   2111         os_error_printf(CU_MSG_INFO2, (PS8)"  Other Failures                : %d\n", txCounters.txCounters[TxQid].OtherFailCounter );
   2112         os_error_printf(CU_MSG_INFO2, (PS8)"  Max Consecutive Retry Failures : %d\n\n", txCounters.txCounters[TxQid].MaxConsecutiveRetryFail );
   2113 
   2114         os_error_printf(CU_MSG_INFO2, (PS8)"  Retry histogram:\n");
   2115         os_error_printf(CU_MSG_INFO2, (PS8)"  ----------------\n\n");
   2116         os_error_printf(CU_MSG_INFO2, (PS8)"  Retries: %8d %8d %8d %8d %8d %8d %8d %8d\n", 0, 1, 2, 3, 4, 5, 6, 7);
   2117         os_error_printf(CU_MSG_INFO2, (PS8)"  packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n",
   2118                                 txCounters.txCounters[TxQid].RetryHistogram[ 0 ],
   2119                                 txCounters.txCounters[TxQid].RetryHistogram[ 1 ],
   2120                                 txCounters.txCounters[TxQid].RetryHistogram[ 2 ],
   2121                                 txCounters.txCounters[TxQid].RetryHistogram[ 3 ],
   2122                                 txCounters.txCounters[TxQid].RetryHistogram[ 4 ],
   2123                                 txCounters.txCounters[TxQid].RetryHistogram[ 5 ],
   2124                                 txCounters.txCounters[TxQid].RetryHistogram[ 6 ],
   2125                                 txCounters.txCounters[TxQid].RetryHistogram[ 7 ]);
   2126         os_error_printf(CU_MSG_INFO2, (PS8)"  Retries: %8d %8d %8d %8d %8d %8d %8d %8d\n", 8, 9, 10, 11, 12, 13, 14, 15);
   2127         os_error_printf(CU_MSG_INFO2, (PS8)"  packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n",
   2128                                 txCounters.txCounters[TxQid].RetryHistogram[ 8 ],
   2129                                 txCounters.txCounters[TxQid].RetryHistogram[ 9 ],
   2130                                 txCounters.txCounters[TxQid].RetryHistogram[ 10 ],
   2131                                 txCounters.txCounters[TxQid].RetryHistogram[ 11 ],
   2132                                 txCounters.txCounters[TxQid].RetryHistogram[ 12 ],
   2133                                 txCounters.txCounters[TxQid].RetryHistogram[ 13 ],
   2134                                 txCounters.txCounters[TxQid].RetryHistogram[ 14 ],
   2135                                 txCounters.txCounters[TxQid].RetryHistogram[ 15 ]);
   2136 
   2137         if (txCounters.txCounters[TxQid].NumPackets)
   2138         {
   2139             AverageDelay = txCounters.txCounters[TxQid].SumTotalDelayMs / txCounters.txCounters[TxQid].NumPackets;
   2140             AverageFWDelay = txCounters.txCounters[TxQid].SumFWDelayUs / txCounters.txCounters[TxQid].NumPackets;
   2141             AverageMacDelay = txCounters.txCounters[TxQid].SumMacDelayUs / txCounters.txCounters[TxQid].NumPackets;
   2142         }
   2143         else
   2144         {
   2145             AverageDelay = 0;
   2146             AverageFWDelay = 0;
   2147             AverageMacDelay = 0;
   2148         }
   2149 
   2150         os_error_printf(CU_MSG_INFO2, (PS8)"  Total Delay ms (average/sum) : %d / %d\n", AverageDelay, txCounters.txCounters[TxQid].SumTotalDelayMs);
   2151         os_error_printf(CU_MSG_INFO2, (PS8)"  FW Delay us (average/sum) : %d / %d\n", AverageFWDelay, txCounters.txCounters[TxQid].SumFWDelayUs);
   2152         os_error_printf(CU_MSG_INFO2, (PS8)"  MAC Delay us (average/sum)   : %d / %d\n\n", AverageMacDelay, txCounters.txCounters[TxQid].SumMacDelayUs);
   2153 
   2154         os_error_printf(CU_MSG_INFO2, (PS8)"  Delay Ranges [msec]  : Num of packets\n");
   2155         os_error_printf(CU_MSG_INFO2, (PS8)"  -------------------  : --------------\n");
   2156         os_error_printf(CU_MSG_INFO2, (PS8)"        0   -    1     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_0_TO_1] );
   2157         os_error_printf(CU_MSG_INFO2, (PS8)"        1   -   10     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_1_TO_10] );
   2158         os_error_printf(CU_MSG_INFO2, (PS8)"       10   -   20     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_10_TO_20] );
   2159         os_error_printf(CU_MSG_INFO2, (PS8)"       20   -   40     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_20_TO_40] );
   2160         os_error_printf(CU_MSG_INFO2, (PS8)"       40   -   60     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_40_TO_60] );
   2161         os_error_printf(CU_MSG_INFO2, (PS8)"       60   -   80     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_60_TO_80] );
   2162         os_error_printf(CU_MSG_INFO2, (PS8)"       80   -  100     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_80_TO_100] );
   2163         os_error_printf(CU_MSG_INFO2, (PS8)"      100   -  200     : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_100_TO_200] );
   2164         os_error_printf(CU_MSG_INFO2, (PS8)"        Above 200      : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_ABOVE_200] );
   2165     }
   2166 }
   2167 
   2168 VOID CuCmd_ShowAdvancedParams(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2169 {
   2170     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2171 
   2172     U32 AuthMode;
   2173     TPowerMgr_PowerMode Mode;
   2174     S32 txPowerLevel;
   2175 #ifndef NO_WPA_SUPPL
   2176     OS_802_11_ENCRYPTION_TYPES EncryptionTypePairwise;
   2177     OS_802_11_ENCRYPTION_TYPES EncryptionTypeGroup;
   2178 #endif
   2179     S32 Preamble;
   2180     S32 FragTh;
   2181     S32 RtsTh;
   2182 
   2183     if (pCuCmd->hWpaCore == NULL)
   2184     {
   2185         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, &AuthMode)) return;
   2186     }
   2187     else
   2188     {
   2189 #ifndef NO_WPA_SUPPL
   2190         if(OK != WpaCore_GetAuthMode(pCuCmd->hWpaCore, &AuthMode)) return;
   2191 #endif
   2192     }
   2193     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET, &Mode, sizeof(TPowerMgr_PowerMode))) return;
   2194     if(OK != CuOs_GetTxPowerLevel(pCuCmd->hCuWext, &txPowerLevel)) return;
   2195 #ifndef NO_WPA_SUPPL
   2196     if(OK != WpaCore_GetEncryptionPairWise(pCuCmd->hWpaCore, &EncryptionTypePairwise)) return;
   2197     if(OK != WpaCore_GetEncryptionGroup(pCuCmd->hWpaCore, &EncryptionTypeGroup)) return;
   2198 #endif
   2199     if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_GET, (PU32)&Preamble)) return;
   2200     if(OK != CuOs_GetFragTh(pCuCmd->hCuWext, &FragTh)) return;
   2201     if(OK != CuOs_GetRtsTh(pCuCmd->hCuWext, &RtsTh)) return;
   2202 
   2203 
   2204     os_error_printf(CU_MSG_INFO2, (PS8)"********************\n");
   2205     os_error_printf(CU_MSG_INFO2, (PS8)"Advanced Statistics:\n");
   2206     os_error_printf(CU_MSG_INFO2, (PS8)"********************\n");
   2207 
   2208     os_error_printf(CU_MSG_INFO2, (PS8)"  Authentication : %u\n", AuthMode );
   2209     os_error_printf(CU_MSG_INFO2, (PS8)"  Power mode : %d\n", Mode.PowerMode );
   2210     os_error_printf(CU_MSG_INFO2, (PS8)"  Tx Power level : %d\n", txPowerLevel );
   2211 #ifndef NO_WPA_SUPPL
   2212     os_error_printf(CU_MSG_INFO2, (PS8)"  Encryption Pairwise: %u\n", EncryptionTypePairwise );
   2213     os_error_printf(CU_MSG_INFO2, (PS8)"  Encryption Group: %u\n", EncryptionTypeGroup );
   2214 #endif
   2215     os_error_printf(CU_MSG_INFO2, (PS8)"  Preamble : <%s>\n", (Preamble) ? "short" : "long");
   2216     os_error_printf(CU_MSG_INFO2, (PS8)"  Frag. threshold : %u\n", FragTh);
   2217     os_error_printf(CU_MSG_INFO2, (PS8)"  RTS threshold : %u\n", RtsTh );
   2218     os_error_printf(CU_MSG_INFO2, (PS8)"  Power mode: ");
   2219     print_available_values(power_mode_val);
   2220     os_error_printf(CU_MSG_INFO2, (PS8)"  Encryption type: ");
   2221     print_available_values(encrypt_type);
   2222 
   2223 }
   2224 
   2225 
   2226 VOID Cucmd_ShowPowerConsumptionStats(THandle hCuCmd,ConParm_t parm[],U16 nParms)
   2227 {
   2228     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2229     ACXPowerConsumptionTimeStat_t tStatistics;
   2230 
   2231     os_memset( &tStatistics, 0, sizeof(ACXPowerConsumptionTimeStat_t) );
   2232 
   2233      if (OK != CuCommon_GetPowerConsumptionStat(pCuCmd->hCuCommon,&tStatistics))
   2234      {
   2235         os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Failed to read power consumption statistic!\n");
   2236         return;
   2237      }
   2238 
   2239 
   2240 
   2241     os_error_printf(CU_MSG_INFO2, (PS8)"\nPower Consumption Statistics:\n");
   2242     os_error_printf(CU_MSG_INFO2, (PS8)"-----------------------------\n");
   2243     os_error_printf(CU_MSG_INFO2, (PS8)"activeTimeCnt:0x%x%x\n", tStatistics.awakeTimeCnt_Hi,tStatistics.awakeTimeCnt_Low );
   2244     os_error_printf(CU_MSG_INFO2, (PS8)"elpTimeCnt: 0x%x%x\n", tStatistics.elpTimeCnt_Hi,tStatistics.elpTimeCnt_Low);
   2245     os_error_printf(CU_MSG_INFO2, (PS8)"powerDownTimeCnt: 0x%x%x\n", tStatistics.powerDownTimeCnt_Hi,tStatistics.powerDownTimeCnt_Low);
   2246     os_error_printf(CU_MSG_INFO2, (PS8)"ListenMode11BTimeCnt: 0x%x%x\n", tStatistics.ListenMode11BTimeCnt_Hi,tStatistics.ListenMode11BTimeCnt_Low);
   2247     os_error_printf(CU_MSG_INFO2, (PS8)"ListenModeOFDMTimeCnt: 0x%x%x\n", tStatistics.ListenModeOFDMTimeCnt_Hi,tStatistics.ListenModeOFDMTimeCnt_Low);
   2248 
   2249 }
   2250 
   2251 
   2252 
   2253 VOID CuCmd_ScanAppGlobalConfig(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2254 {
   2255     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2256 
   2257     if ( 0 == os_strcmp( (PS8)"<empty>", (PS8)parm[0].value) )
   2258     {
   2259         pCuCmd->appScanParams.desiredSsid.len = 0;
   2260         pCuCmd->appScanParams.desiredSsid.str[ 0 ] = '\0';
   2261     }
   2262     else
   2263     {
   2264         pCuCmd->appScanParams.desiredSsid.len = (U8) os_strlen((PS8)parm[0].value);
   2265         os_memcpy( (PVOID)&(pCuCmd->appScanParams.desiredSsid.str), (PVOID)parm[0].value, pCuCmd->appScanParams.desiredSsid.len );
   2266         if(pCuCmd->appScanParams.desiredSsid.len < MAX_SSID_LEN)
   2267         {
   2268             pCuCmd->appScanParams.desiredSsid.str[pCuCmd->appScanParams.desiredSsid.len] = 0;
   2269         }
   2270     }
   2271     pCuCmd->appScanParams.scanType = parm[1].value;
   2272     pCuCmd->appScanParams.band = parm[2].value;
   2273     pCuCmd->appScanParams.probeReqNumber = (U8)parm[3].value;
   2274     pCuCmd->appScanParams.probeRequestRate = parm[4].value;
   2275 #ifdef TI_DBG
   2276     pCuCmd->appScanParams.Tid = (U8)parm[5].value;
   2277     pCuCmd->appScanParams.numOfChannels  = (U8)parm[6].value;
   2278 #else
   2279     pCuCmd->appScanParams.Tid = 0;
   2280     pCuCmd->appScanParams.numOfChannels = (U8)parm[5].value;
   2281 #endif
   2282 }
   2283 
   2284 VOID CuCmd_ScanAppChannelConfig(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2285 {
   2286     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2287 
   2288     scan_normalChannelEntry_t* pChannelEntry =
   2289         &(pCuCmd->appScanParams.channelEntry[ parm[0].value ].normalChannelEntry);
   2290 
   2291     if (parm[2].value < parm[3].value)
   2292     {
   2293         os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
   2294         return;
   2295     }
   2296 
   2297     CuCmd_Str2MACAddr ((PS8)parm[1].value, pChannelEntry->bssId);
   2298     pChannelEntry->maxChannelDwellTime = parm[2].value;
   2299     pChannelEntry->minChannelDwellTime = parm[3].value;
   2300     pChannelEntry->earlyTerminationEvent = parm[4].value;
   2301     pChannelEntry->ETMaxNumOfAPframes = (U8)parm[5].value;
   2302     pChannelEntry->txPowerDbm = (U8)parm[6].value;
   2303     pChannelEntry->channel = (U8)parm[7].value;
   2304 }
   2305 
   2306 VOID CuCmd_ScanAppClear(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2307 {
   2308     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2309     os_memset( &pCuCmd->appScanParams, 0, sizeof(scan_Params_t) );
   2310     os_error_printf(CU_MSG_INFO2, (PS8)"Application scan parameters cleared.\n");
   2311 }
   2312 
   2313 VOID CuCmd_ScanAppDisplay(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2314 {
   2315     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2316     S32 i,j;
   2317     scan_normalChannelEntry_t* pNormalChannel;
   2318 
   2319     CU_CMD_FIND_NAME_ARRAY(j, rate2Str, pCuCmd->appScanParams.probeRequestRate);
   2320     os_error_printf(CU_MSG_INFO2, (PS8)"Application Scan params:\n");
   2321     os_error_printf(CU_MSG_INFO2, (PS8)"SSID: %s, Type: %s\n",
   2322         pCuCmd->appScanParams.desiredSsid.str,
   2323         scanType2Str[ pCuCmd->appScanParams.scanType ].name);
   2324     os_error_printf(CU_MSG_INFO2, (PS8)"Band: %s, Number of probe req:%d, probe req. rate:%s\n",
   2325         band2Str[ pCuCmd->appScanParams.band ].name,
   2326         pCuCmd->appScanParams.probeReqNumber,
   2327         rate2Str[j].name);
   2328 #ifdef TI_DBG
   2329     os_error_printf(CU_MSG_INFO2, (PS8)"Tid :%d\n\n", pCuCmd->appScanParams.Tid);
   2330 #else
   2331     os_error_printf(CU_MSG_INFO2, (PS8)"\n");
   2332 #endif
   2333     os_error_printf(CU_MSG_INFO2, (PS8)"Channel  BSS ID             Max time  Min time  ET event     ET frame num Power\n");
   2334     os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------------------------------------------------------\n");
   2335     for ( i = 0; i < pCuCmd->appScanParams.numOfChannels; i++ )
   2336     {
   2337         pNormalChannel = &(pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry);
   2338         CU_CMD_FIND_NAME_ARRAY(j, EtEvent2Str, pNormalChannel->earlyTerminationEvent);
   2339         os_error_printf(CU_MSG_INFO2, (PS8)"%2d       %02x.%02x.%02x.%02x.%02x.%02x  %7d   %7d   %s%3d          %1d\n",
   2340                pNormalChannel->channel,
   2341                pNormalChannel->bssId[0],pNormalChannel->bssId[1],pNormalChannel->bssId[2],pNormalChannel->bssId[3],pNormalChannel->bssId[4],pNormalChannel->bssId[5],
   2342                pNormalChannel->maxChannelDwellTime,
   2343                pNormalChannel->minChannelDwellTime,
   2344                EtEvent2Str[j].name,
   2345                pNormalChannel->ETMaxNumOfAPframes,
   2346                pNormalChannel->txPowerDbm);
   2347     }
   2348     os_error_printf(CU_MSG_INFO2, (PS8)"\n");
   2349 }
   2350 
   2351 VOID CuCmd_ScanSetSra(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2352 {
   2353     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2354 
   2355     if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, SCAN_CNCN_SET_SRA, parm[0].value) )
   2356     {
   2357         os_error_printf(CU_MSG_INFO2, (PS8) "Failed setting Scan Result Aging");
   2358     }
   2359     os_error_printf(CU_MSG_INFO2, (PS8) "Scan Result Aging set succesfully to %d seconds", parm[0].value);
   2360 }
   2361 
   2362 VOID CuCmd_ScanSetRssi(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2363 {
   2364     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2365 
   2366     if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, SCAN_CNCN_SET_RSSI, parm[0].value) )
   2367     {
   2368         os_error_printf(CU_MSG_INFO2, (PS8) "Failed setting Rssi filter threshold");
   2369     }
   2370     os_error_printf(CU_MSG_INFO2, (PS8) "Rssi filter set succesfully to %d", parm[0].value);
   2371 }
   2372 
   2373 VOID CuCmd_StartScan(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2374 {
   2375     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2376 
   2377     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_START_APP_SCAN_SET,
   2378         &pCuCmd->appScanParams, sizeof(scan_Params_t)))
   2379     {
   2380         return;
   2381     }
   2382 
   2383     os_error_printf(CU_MSG_INFO2, (PS8)"Application scan started\n");
   2384 
   2385     /*
   2386 	 * In order to have ability to set the application scan we are using application scan priver command
   2387 	 * exsample for using supplicant scan command below:
   2388 	 * #ifndef NO_WPA_SUPPL
   2389      *       CuOs_Start_Scan(pCuCmd->hCuWext, &ssid);
   2390 	 * #endif
   2391 	 */
   2392 }
   2393 
   2394 VOID CuCmd_WextStartScan(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2395 {
   2396     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2397     OS_802_11_SSID ssid;
   2398 	U8 scanType =0;
   2399 
   2400     switch (nParms)
   2401     {
   2402 		case 0:
   2403 			ssid.SsidLength = 0;
   2404             ssid.Ssid[0] = 0;
   2405 			scanType = 0;
   2406 			break;
   2407         case 1 :
   2408             /*
   2409             *  No SSID & No BSSID are set -
   2410             *  Use Any SSID & Any BSSID.
   2411             */
   2412             ssid.SsidLength = 0;
   2413             ssid.Ssid[0] = 0;
   2414 			scanType = (U8)parm[0].value;
   2415             break;
   2416 
   2417         case 2:
   2418             /*
   2419             *  SSID set
   2420             *  Use CLI's SSID & Any BSSID.
   2421             */
   2422             ssid.SsidLength = os_strlen( (PS8)parm[1].value);
   2423 			os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[1].value, ssid.SsidLength);
   2424             ssid.Ssid[ssid.SsidLength] = '\0';
   2425 			scanType = (U8)parm[0].value; /* 0 - Active , 1 - Passive*/
   2426             break;
   2427 
   2428         default:
   2429             os_error_printf(CU_MSG_ERROR, (PS8)"<Scan Type [0=Active, 1=Passive]> <ssid Name As optional>\n");
   2430             return;
   2431     }
   2432 
   2433 
   2434 
   2435 #ifndef NO_WPA_SUPPL
   2436     CuOs_Start_Scan(pCuCmd->hCuWext, &ssid, scanType);
   2437 #else
   2438     os_error_printf(CU_MSG_INFO2, (PS8)"WEXT not build, Scan Not Started\n");
   2439 #endif
   2440 
   2441 }
   2442 
   2443 VOID CuCmd_StopScan (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2444 {
   2445     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2446 
   2447     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_STOP_APP_SCAN_SET, NULL, 0))
   2448     {
   2449         return;
   2450     }
   2451     os_error_printf(CU_MSG_INFO2, (PS8)"Application scan stopped\n");
   2452 }
   2453 
   2454 VOID CuCmd_ConfigPeriodicScanGlobal (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2455 {
   2456     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2457 
   2458     pCuCmd->tPeriodicAppScanParams.iRssiThreshold = (S8)parm[ 0 ].value;
   2459     pCuCmd->tPeriodicAppScanParams.iSnrThreshold = (S8)parm[ 1 ].value;
   2460     pCuCmd->tPeriodicAppScanParams.uFrameCountReportThreshold = parm[ 2 ].value;
   2461     pCuCmd->tPeriodicAppScanParams.bTerminateOnReport = parm[ 3 ].value;
   2462     pCuCmd->tPeriodicAppScanParams.eBssType = (ScanBssType_e )parm[ 4 ].value;
   2463     pCuCmd->tPeriodicAppScanParams.uProbeRequestNum = parm[ 5 ].value;
   2464     pCuCmd->tPeriodicAppScanParams.uCycleNum = parm[ 6 ].value;
   2465     pCuCmd->tPeriodicAppScanParams.uSsidNum = parm[ 7 ].value;
   2466     pCuCmd->tPeriodicAppScanParams.uSsidListFilterEnabled = (U8)(parm[ 8 ].value);
   2467     pCuCmd->tPeriodicAppScanParams.uChannelNum = parm[ 9 ].value;
   2468 }
   2469 
   2470 VOID CuCmd_ConfigPeriodicScanInterval (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2471 {
   2472     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2473 
   2474     pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ parm[ 0 ].value ] = parm[ 1 ].value;
   2475 }
   2476 
   2477 VOID CuCmd_ConfigurePeriodicScanSsid (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2478 {
   2479     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2480     TSsid *pSsid = &pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ parm[ 0 ].value ].tSsid;
   2481 
   2482     pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ parm[ 0 ].value ].eVisability = parm[ 1 ].value;
   2483     pSsid->len = (U8)os_strlen ((PS8)parm[ 2 ].value);
   2484     os_memcpy ((PVOID)&(pSsid->str),
   2485                (PVOID)parm[ 2 ].value,
   2486                pSsid->len);
   2487     if(pSsid->len < MAX_SSID_LEN)
   2488     {
   2489         pSsid->str[pSsid->len] = 0;
   2490     }
   2491 }
   2492 
   2493 VOID CuCmd_ConfigurePeriodicScanChannel (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2494 {
   2495     CuCmd_t                 *pCuCmd = (CuCmd_t*)hCuCmd;
   2496     TPeriodicChannelEntry   *pChannelEnrty = &(pCuCmd->tPeriodicAppScanParams.tChannels[ parm[ 0 ].value ]);
   2497 
   2498     pChannelEnrty->eBand = parm[ 1 ].value;
   2499     pChannelEnrty->uChannel = parm[ 2 ].value;
   2500     pChannelEnrty->eScanType = parm[ 3 ].value;
   2501     pChannelEnrty->uMinDwellTimeMs = parm[ 4 ].value;;
   2502     pChannelEnrty->uMaxDwellTimeMs = parm[ 5 ].value;
   2503     pChannelEnrty->uTxPowerLevelDbm = parm[ 6 ].value;
   2504 }
   2505 
   2506 VOID CuCmd_ClearPeriodicScanConfiguration (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2507 {
   2508     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2509 
   2510     os_memset (&(pCuCmd->tPeriodicAppScanParams), 0, sizeof (TPeriodicScanParams));
   2511     os_error_printf(CU_MSG_INFO2, (PS8)"Periodic application scan parameters cleared.\n");
   2512 }
   2513 
   2514 VOID CuCmd_DisplayPeriodicScanConfiguration (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2515 {
   2516     CuCmd_t*    pCuCmd = (CuCmd_t*)hCuCmd;
   2517     S32         i, j, k;
   2518 
   2519     os_error_printf(CU_MSG_INFO2, (PS8)"Application Periodic Scan parameters:\n");
   2520     os_error_printf(CU_MSG_INFO2, (PS8)"RSSI Threshold: %d, SNR Threshold: %d, Report Threshold: %d  Number of cycles: %d\n",
   2521                     pCuCmd->tPeriodicAppScanParams.iRssiThreshold, pCuCmd->tPeriodicAppScanParams.iSnrThreshold,
   2522                     pCuCmd->tPeriodicAppScanParams.uFrameCountReportThreshold, pCuCmd->tPeriodicAppScanParams.uCycleNum);
   2523     CU_CMD_FIND_NAME_ARRAY (i, booleanStr, pCuCmd->tPeriodicAppScanParams.bTerminateOnReport);
   2524     CU_CMD_FIND_NAME_ARRAY (j, bssTypeStr, pCuCmd->tPeriodicAppScanParams.eBssType);
   2525     os_error_printf(CU_MSG_INFO2, (PS8)"Terminate on Report: %s, BSS type: %s, Probe Request Number: %d\n",
   2526                     booleanStr[ i ].name, bssTypeStr[ j ].name, pCuCmd->tPeriodicAppScanParams.uProbeRequestNum);
   2527 
   2528     os_error_printf(CU_MSG_INFO2, (PS8)"\nIntervals (msec):\n");
   2529     for (i = 0; i < PERIODIC_SCAN_MAX_INTERVAL_NUM; i++)
   2530     {
   2531         os_error_printf(CU_MSG_INFO2, (PS8)"%d ", pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ i ]);
   2532     }
   2533     os_error_printf(CU_MSG_INFO2, (PS8)"\n\nSSIDs:\n");
   2534     for (i = 0; i < (S32)pCuCmd->tPeriodicAppScanParams.uSsidNum; i++)
   2535     {
   2536         CU_CMD_FIND_NAME_ARRAY (j, ssidVisabilityStr, pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ i ].eVisability);
   2537         os_error_printf(CU_MSG_INFO2, (PS8)"%s (%s), ", pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ i ].tSsid.str,
   2538                         ssidVisabilityStr[ j ].name);
   2539     }
   2540     os_error_printf(CU_MSG_INFO2, (PS8)"\n\nSSID List Filter Enabled: %d\n", pCuCmd->tPeriodicAppScanParams.uSsidListFilterEnabled );
   2541 
   2542     os_error_printf(CU_MSG_INFO2, (PS8)"\n\nChannels:\n");
   2543     os_error_printf(CU_MSG_INFO2, (PS8)"%-15s %-10s %-20s %-15s %-15s %-20s\n",
   2544                     (PS8)"Band", (PS8)"Channel", (PS8)"Scan type", (PS8)"Min dwell time", (PS8)"Max dwell time", (PS8)"Power level (dBm*10)");
   2545     os_error_printf(CU_MSG_INFO2, (PS8)"----------------------------------------------------------------------------------------------------\n");
   2546     for (i = 0; i < (S32)pCuCmd->tPeriodicAppScanParams.uChannelNum; i++)
   2547     {
   2548         CU_CMD_FIND_NAME_ARRAY (j, band2Str, pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eBand);
   2549         CU_CMD_FIND_NAME_ARRAY (k, scanType2Str, pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eScanType);
   2550         os_error_printf(CU_MSG_INFO2, (PS8)"%-15s %-10d %-20s %-15d %-15d %-20d\n",
   2551                         band2Str[ j ].name,
   2552                         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uChannel,
   2553                         scanType2Str[ k ].name,
   2554                         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMinDwellTimeMs,
   2555                         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMaxDwellTimeMs,
   2556                         pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uTxPowerLevelDbm);
   2557     }
   2558     os_error_printf(CU_MSG_INFO2, (PS8)"\n");
   2559 }
   2560 
   2561 VOID CuCmd_StartPeriodicScan (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2562 {
   2563     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2564 
   2565     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, SCAN_CNCN_START_PERIODIC_SCAN,
   2566                                 &(pCuCmd->tPeriodicAppScanParams), sizeof(TPeriodicScanParams)))
   2567     {
   2568         return;
   2569     }
   2570     os_error_printf(CU_MSG_INFO2, (PS8)"Periodic application scan started.\n");
   2571 }
   2572 
   2573 VOID CuCmd_StopPeriodicScan (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2574 {
   2575     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2576 
   2577     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, SCAN_CNCN_STOP_PERIODIC_SCAN,
   2578                                 NULL, 0))
   2579     {
   2580         return;
   2581     }
   2582     os_error_printf(CU_MSG_INFO2, (PS8)"Periodic application scan stopped.\n");
   2583 }
   2584 
   2585 VOID CuCmd_ConfigScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2586 {
   2587     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2588 
   2589     pCuCmd->scanPolicy.normalScanInterval =  parm[ 0 ].value;
   2590     pCuCmd->scanPolicy.deterioratingScanInterval = parm[ 1 ].value;
   2591     pCuCmd->scanPolicy.maxTrackFailures = (U8)(parm[ 2 ].value);
   2592     pCuCmd->scanPolicy.BSSListSize = (U8)(parm[ 3 ].value);
   2593     pCuCmd->scanPolicy.BSSNumberToStartDiscovery = (U8)(parm[ 4 ].value);
   2594     pCuCmd->scanPolicy.numOfBands = (U8)(parm[ 5 ].value);
   2595 }
   2596 
   2597 VOID CuCmd_ConfigScanBand(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2598 {
   2599     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2600     scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
   2601 
   2602     pBandPolicy->band = parm[ 1 ].value;
   2603     pBandPolicy->rxRSSIThreshold = (S8)(parm[ 2 ].value);
   2604     pBandPolicy->numOfChannlesForDiscovery = (U8)(parm[ 3 ].value);
   2605     pBandPolicy->numOfChannles = (U8)(parm[ 4 ].value);
   2606 }
   2607 
   2608 VOID CuCmd_ConfigScanBandChannel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2609 {
   2610     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2611     scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
   2612 
   2613     pBandPolicy->channelList[ parm[ 1 ].value ] = (U8)(parm[ 2 ].value);
   2614 }
   2615 
   2616 VOID CuCmd_ConfigScanBandTrack(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2617 {
   2618     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2619     scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
   2620 
   2621     if (parm[6].value < parm[7].value)
   2622     {
   2623         os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
   2624         return;
   2625     }
   2626 
   2627     pBandPolicy->trackingMethod.scanType = parm[ 1 ].value;
   2628 
   2629     switch (pBandPolicy->trackingMethod.scanType)
   2630     {
   2631         case SCAN_TYPE_NORMAL_ACTIVE:
   2632         case SCAN_TYPE_NORMAL_PASSIVE:
   2633             pBandPolicy->trackingMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
   2634             pBandPolicy->trackingMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
   2635             pBandPolicy->trackingMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2636             pBandPolicy->trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2637             pBandPolicy->trackingMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
   2638             pBandPolicy->trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value);
   2639             pBandPolicy->trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value);
   2640             break;
   2641 
   2642         case SCAN_TYPE_TRIGGERED_ACTIVE:
   2643         case SCAN_TYPE_TRIGGERED_PASSIVE:
   2644             /* Check if valid TID */
   2645             if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255))
   2646             {
   2647                 os_error_printf (CU_MSG_INFO2, (PS8)"ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
   2648                 parm[ 4 ].value = 255;
   2649             }
   2650 
   2651             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.triggeringTid = (U8)(parm[ 4 ].value);
   2652             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
   2653             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
   2654             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2655             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2656             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
   2657             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value);
   2658             pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value);
   2659             break;
   2660 
   2661         case SCAN_TYPE_SPS:
   2662             pBandPolicy->trackingMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2663             pBandPolicy->trackingMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2664             pBandPolicy->trackingMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
   2665             break;
   2666 
   2667         default:
   2668             pBandPolicy->trackingMethod.scanType = SCAN_TYPE_NO_SCAN;
   2669             break;
   2670     }
   2671 }
   2672 
   2673 VOID CuCmd_ConfigScanBandDiscover(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2674 {
   2675     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2676     scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
   2677 
   2678     if (parm[6].value < parm[7].value)
   2679     {
   2680         os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
   2681         return;
   2682     }
   2683 
   2684     pBandPolicy->discoveryMethod.scanType = parm[ 1 ].value;
   2685 
   2686     switch (pBandPolicy->discoveryMethod.scanType)
   2687     {
   2688         case SCAN_TYPE_NORMAL_ACTIVE:
   2689         case SCAN_TYPE_NORMAL_PASSIVE:
   2690             pBandPolicy->discoveryMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
   2691             pBandPolicy->discoveryMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
   2692             pBandPolicy->discoveryMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2693             pBandPolicy->discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2694             pBandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
   2695             pBandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value);
   2696             pBandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value);
   2697             break;
   2698 
   2699         case SCAN_TYPE_TRIGGERED_ACTIVE:
   2700         case SCAN_TYPE_TRIGGERED_PASSIVE:
   2701             /* Check if valid TID */
   2702             if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255))
   2703             {
   2704                 os_error_printf(CU_MSG_INFO2, (PS8)"ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
   2705                 parm[ 4 ].value = 255;
   2706             }
   2707 
   2708             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.triggeringTid = (U8)(parm[ 4 ].value);
   2709             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
   2710             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
   2711             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2712             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2713             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
   2714             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value);
   2715             pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value);
   2716             break;
   2717 
   2718         case SCAN_TYPE_SPS:
   2719             pBandPolicy->discoveryMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2720             pBandPolicy->discoveryMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2721             pBandPolicy->discoveryMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
   2722             break;
   2723 
   2724         default:
   2725             pBandPolicy->discoveryMethod.scanType = SCAN_TYPE_NO_SCAN;
   2726             break;
   2727     }
   2728 }
   2729 
   2730 VOID CuCmd_ConfigScanBandImmed(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2731 {
   2732     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2733     scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
   2734 
   2735     if (parm[6].value < parm[7].value)
   2736     {
   2737         os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
   2738         return;
   2739     }
   2740 
   2741     pBandPolicy->immediateScanMethod.scanType = parm[ 1 ].value;
   2742 
   2743     switch (pBandPolicy->immediateScanMethod.scanType)
   2744     {
   2745         case SCAN_TYPE_NORMAL_ACTIVE:
   2746         case SCAN_TYPE_NORMAL_PASSIVE:
   2747             pBandPolicy->immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
   2748             pBandPolicy->immediateScanMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
   2749             pBandPolicy->immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2750             pBandPolicy->immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2751             pBandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
   2752             pBandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value);
   2753             pBandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value);
   2754             break;
   2755 
   2756         case SCAN_TYPE_TRIGGERED_ACTIVE:
   2757         case SCAN_TYPE_TRIGGERED_PASSIVE:
   2758             /* Check if valid TID */
   2759             if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255))
   2760             {
   2761                 os_error_printf (CU_MSG_INFO2, (PS8)"ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
   2762                 parm[ 4 ].value = 255;
   2763             }
   2764 
   2765             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.triggeringTid = (U8)(parm[ 4 ].value);
   2766             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
   2767             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
   2768             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2769             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2770             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
   2771             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value);
   2772             pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value);
   2773             break;
   2774 
   2775         case SCAN_TYPE_SPS:
   2776             pBandPolicy->immediateScanMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
   2777             pBandPolicy->immediateScanMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value);
   2778             pBandPolicy->immediateScanMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
   2779             break;
   2780 
   2781         default:
   2782             pBandPolicy->immediateScanMethod.scanType = SCAN_TYPE_NO_SCAN;
   2783             break;
   2784     }
   2785 }
   2786 
   2787 VOID CuCmd_DisplayScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2788 {
   2789     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2790     S32 i;
   2791 
   2792     os_error_printf(CU_MSG_INFO2, (PS8)"Scan Policy:\n");
   2793     os_error_printf(CU_MSG_INFO2, (PS8)"Normal scan interval: %d, deteriorating scan interval: %d\n",
   2794           pCuCmd->scanPolicy.normalScanInterval, pCuCmd->scanPolicy.deterioratingScanInterval);
   2795     os_error_printf(CU_MSG_INFO2, (PS8)"Max track attempt failures: %d\n", pCuCmd->scanPolicy.maxTrackFailures);
   2796     os_error_printf(CU_MSG_INFO2, (PS8)"BSS list size: %d, number of BSSes to start discovery: %d\n",
   2797           pCuCmd->scanPolicy.BSSListSize, pCuCmd->scanPolicy.BSSNumberToStartDiscovery);
   2798     os_error_printf(CU_MSG_INFO2, (PS8)"Number of configured bands: %d\n", pCuCmd->scanPolicy.numOfBands);
   2799     for ( i = 0; i < pCuCmd->scanPolicy.numOfBands; i++ )
   2800     {
   2801         CuCmd_PrintScanBand(&(pCuCmd->scanPolicy.bandScanPolicy[ i ]));
   2802     }
   2803 }
   2804 
   2805 VOID CuCmd_ClearScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2806 {
   2807     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2808 
   2809     os_memset( &pCuCmd->scanPolicy, 0, sizeof(scan_Policy_t) );
   2810     os_error_printf(CU_MSG_INFO2, (PS8)"Scan policy cleared.\n");
   2811 }
   2812 
   2813 VOID CuCmd_SetScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2814 {
   2815     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2816 
   2817     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SCAN_POLICY_PARAM_SET,
   2818         &pCuCmd->scanPolicy, sizeof(scan_Policy_t))) return;
   2819     os_error_printf(CU_MSG_INFO2, (PS8)"Scan policy stored.\n");
   2820 }
   2821 
   2822 VOID CuCmd_GetScanBssList(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2823 {
   2824     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2825     bssList_t list;
   2826     S32 i;
   2827 
   2828     if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SCAN_BSS_LIST_GET,
   2829         &list, sizeof(bssList_t))) return;
   2830 
   2831     /* os_error_printf list */
   2832     os_error_printf(CU_MSG_INFO2, (PS8)"BSS List:\n");
   2833     os_error_printf(CU_MSG_INFO2, (PS8)"%-17s  %-7s  %-6s  %-4s  %-10s\n", (PS8)"BSSID", (PS8)"Band", (PS8)"Channel", (PS8)"RSSI", (PS8)"Neighbor?");
   2834     os_error_printf(CU_MSG_INFO2, (PS8)"-----------------------------------------------------\n");
   2835     for  ( i = 0; i < list.numOfEntries; i++ )
   2836     {
   2837         os_error_printf(CU_MSG_INFO2,  (PS8)"%02x.%02x.%02x.%02x.%02x.%02x  %s  %-7d  %-4d  %s\n",
   2838                list.BSSList[i].BSSID[0], list.BSSList[i].BSSID[1], list.BSSList[i].BSSID[2], list.BSSList[i].BSSID[3], list.BSSList[i].BSSID[4], list.BSSList[i].BSSID[5],
   2839                band2Str[ list.BSSList[ i ].band ].name,
   2840                list.BSSList[ i ].channel, list.BSSList[ i ].RSSI,
   2841                (TRUE == list.BSSList[ i ].bNeighborAP ? (PS8)"Yes" : (PS8)"No") );
   2842     }
   2843 }
   2844 
   2845 VOID CuCmd_RoamingEnable(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2846 {
   2847     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2848     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2849 
   2850     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2851         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t))) return;
   2852     roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_ENABLED;
   2853     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2854         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2855     os_error_printf(CU_MSG_INFO2, (PS8)"Roaming is enabled \n");
   2856 }
   2857 
   2858 VOID CuCmd_RoamingDisable(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2859 {
   2860     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2861     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2862 
   2863     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2864         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2865     roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_DISABLED;
   2866     if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2867         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2868     os_error_printf(CU_MSG_INFO2, (PS8)"Roaming is disabled \n");
   2869 }
   2870 
   2871 VOID CuCmd_RoamingLowPassFilter(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2872 {
   2873     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2874     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2875 
   2876     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2877         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2878     if( nParms != 0 )
   2879     {
   2880         roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt = (U16) parm[0].value;
   2881         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2882             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2883     }
   2884     os_error_printf(CU_MSG_INFO2, (PS8)"Time in sec to wait before low quality Roaming Triggers, \n lowPassFilterRoamingAttempt = %d sec\n",
   2885            roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt);
   2886 }
   2887 
   2888 VOID CuCmd_RoamingQualityIndicator(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2889 {
   2890     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2891     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2892 
   2893     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2894         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2895     if( nParms != 0 )
   2896     {
   2897         roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold = (S8) parm[0].value;
   2898         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2899             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2900     }
   2901     os_error_printf(CU_MSG_INFO2, (PS8)"Quality indicator (RSSI) to be used when comparing AP List matching quality, \n apQualityThreshold = %d \n",
   2902            (roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold));
   2903 }
   2904 
   2905 VOID CuCmd_RoamingDataRetryThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2906 {
   2907     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2908     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2909 
   2910     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2911         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2912     if( nParms != 0 )
   2913     {
   2914         roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold =  (S8) parm[0].value;
   2915         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2916             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2917     }
   2918     os_error_printf(CU_MSG_INFO2, (PS8)"dataRetryThreshold = %d \n",
   2919            roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold);
   2920 
   2921 }
   2922 VOID CuCmd_RoamingNumExpectedTbttForBSSLoss(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2923 {
   2924     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2925     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2926 
   2927     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2928         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2929     if( nParms != 0 )
   2930     {
   2931         roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss =  (S8) parm[0].value;
   2932         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2933             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2934     }
   2935     os_error_printf(CU_MSG_INFO2, (PS8)"Number of expected TBTTs for BSS Loss event, \n numExpectedTbttForBSSLoss = %d \n",
   2936            roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss);
   2937 
   2938 }
   2939 VOID CuCmd_RoamingTxRateThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2940 {
   2941     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2942     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2943 
   2944     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2945         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2946     if( nParms != 0 )
   2947     {
   2948         roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold =  (S8 )parm[0].value;
   2949         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2950             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2951     }
   2952     os_error_printf(CU_MSG_INFO2, (PS8)"txRateThreshold = %d \n",
   2953            roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold);
   2954 
   2955 }
   2956 
   2957 VOID CuCmd_RoamingLowRssiThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2958 {
   2959     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2960     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2961 
   2962     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2963         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2964     if( nParms != 0 )
   2965     {
   2966         roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold =  (S8) parm[0].value;
   2967         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2968             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2969     }
   2970     os_error_printf(CU_MSG_INFO2, (PS8)"lowRssiThreshold = %d \n",
   2971            (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold));
   2972 
   2973 }
   2974 
   2975 VOID CuCmd_RoamingLowSnrThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2976 {
   2977     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2978     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2979 
   2980     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2981         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2982     if( nParms != 0 )
   2983     {
   2984         roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold =  (S8)parm[0].value;
   2985         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2986             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2987     }
   2988     os_error_printf(CU_MSG_INFO2, (PS8)"lowSnrThreshold = %d \n", roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold);
   2989 }
   2990 
   2991 VOID CuCmd_RoamingLowQualityForBackgroungScanCondition(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   2992 {
   2993     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   2994     roamingMngrConfigParams_t   roamingMngrConfigParams;
   2995 
   2996     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   2997         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   2998     if( nParms != 0 )
   2999     {
   3000         roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition = (S8) parm[0].value;
   3001         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   3002             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   3003     }
   3004     os_error_printf(CU_MSG_INFO2, (PS8)"Indicator used to increase the background scan period when quality is low, \n lowQualityForBackgroungScanCondition = %d \n",
   3005            (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition));
   3006 
   3007 }
   3008 
   3009 VOID CuCmd_RoamingNormalQualityForBackgroungScanCondition(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3010 {
   3011     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3012     roamingMngrConfigParams_t   roamingMngrConfigParams;
   3013 
   3014     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   3015         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   3016     if( nParms != 0 )
   3017     {
   3018         roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition = (S8) parm[0].value;
   3019         if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   3020             &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   3021     }
   3022     os_error_printf(CU_MSG_INFO2, (PS8)"Indicator used to reduce the background scan period when quality is normal, \n normalQualityForBackgroungScanCondition = %d \n",
   3023            (roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition));
   3024 
   3025 }
   3026 
   3027 VOID CuCmd_RoamingGetConfParams(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3028 {
   3029     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3030     roamingMngrConfigParams_t   roamingMngrConfigParams;
   3031 
   3032     if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION,
   3033         &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return;
   3034 
   3035     os_error_printf(CU_MSG_INFO2, (PS8)"Roaming is: %s \n", roamingMngrConfigParams.roamingMngrConfig.enableDisable ? "Enabled" : "Disabled\n");
   3036     os_error_printf(CU_MSG_INFO2, (PS8)" lowPassFilterRoamingAttempt = %d sec,\n apQualityThreshold = %d\n",
   3037         roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt,
   3038         roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold);
   3039     os_error_printf(CU_MSG_INFO2, (PS8)" Roaming Triggers' thresholds are: \n");
   3040     os_error_printf(CU_MSG_INFO2, (PS8)" dataRetryThreshold = %d,\n lowQualityForBackgroungScanCondition = %d,\n lowRssiThreshold = %d,\n lowSnrThreshold = %d,\n normalQualityForBackgroungScanCondition = %d,\n numExpectedTbttForBSSLoss = %d,\n txRateThreshold = %d \n",
   3041 					roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold,
   3042 					roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition,
   3043 					roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold,
   3044 					roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold,
   3045 					roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition,
   3046 					roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss,
   3047 					roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold);
   3048 }
   3049 
   3050 VOID CuCmd_CurrBssUserDefinedTrigger(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3051 {
   3052     CuCmd_t *pCuCmd = (CuCmd_t*)hCuCmd;
   3053     TUserDefinedQualityTrigger  userTrigger;
   3054 
   3055     if (nParms == 0)
   3056         return;
   3057 
   3058     userTrigger.uIndex     = (U8)parm[0].value;
   3059     userTrigger.iThreshold = (U16)parm[1].value;
   3060     userTrigger.uPacing    = (U16)parm[2].value;
   3061     userTrigger.uMetric    = (U8)parm[3].value;
   3062     userTrigger.uType      = (U8)parm[4].value;
   3063     userTrigger.uDirection = (U8)parm[5].value;
   3064     userTrigger.uHystersis = (U8)parm[6].value;
   3065     userTrigger.uEnable    = (U8)parm[7].value;
   3066 
   3067     userTrigger.uClientID = 0; /* '0' means that external application with no clientId has registered for the event */
   3068 
   3069     if (OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, CURR_BSS_REGISTER_LINK_QUALITY_EVENT_PARAM,
   3070                                   &userTrigger, sizeof(TUserDefinedQualityTrigger)) )
   3071         return;
   3072 
   3073     os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RoamingUserDefinedTrigger: \n \
   3074           index = %d, \n \
   3075           threshold = %d, \n \
   3076           pacing = %d, \n \
   3077           metric = %d, \n \
   3078           type = %d, \n \
   3079           direction = %d, \n \
   3080           hystersis = %d, \n \
   3081           enable = %d \n",
   3082           userTrigger.uIndex,
   3083           userTrigger.iThreshold,
   3084           userTrigger.uPacing,
   3085           userTrigger.uMetric,
   3086           userTrigger.uType,
   3087           userTrigger.uDirection,
   3088           userTrigger.uHystersis,
   3089           userTrigger.uEnable);
   3090 }
   3091 
   3092 VOID CuCmd_AddTspec(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3093 {
   3094     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3095     OS_802_11_QOS_TSPEC_PARAMS TspecParams;
   3096 
   3097     TspecParams.uUserPriority = parm[0].value;
   3098     TspecParams.uNominalMSDUsize = parm[1].value;
   3099     TspecParams.uMeanDataRate = parm[2].value;
   3100     TspecParams.uMinimumPHYRate = parm[3].value * 1000 * 1000;
   3101     TspecParams.uSurplusBandwidthAllowance = parm[4].value << 13;
   3102     TspecParams.uAPSDFlag = parm[5].value;
   3103     TspecParams.uMinimumServiceInterval = parm[6].value;
   3104     TspecParams.uMaximumServiceInterval = parm[7].value;
   3105 
   3106     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_ADD_TSPEC,
   3107         &TspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS))) return;
   3108 
   3109     os_error_printf(CU_MSG_INFO2, (PS8)"TSpec request sent to driver...\n uUserPriority = %d\n uNominalMSDUsize = %d\n uMeanDataRate = %d\n uMinimumPHYRate = %d\n uSurplusBandwidthAllowance = %d\n uAPSDFlag = %d uMinimumServiceInterval = %d uMaximumServiceInterval = %d\n",
   3110                parm[0].value,
   3111                parm[1].value,
   3112                parm[2].value,
   3113                parm[3].value,
   3114                parm[4].value,
   3115                parm[5].value,
   3116                parm[6].value,
   3117                parm[7].value);
   3118 
   3119 }
   3120 
   3121 VOID CuCmd_GetTspec(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3122 {
   3123     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3124     OS_802_11_QOS_TSPEC_PARAMS TspecParams;
   3125 
   3126     TspecParams.uUserPriority = parm[0].value;
   3127 
   3128     if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_TSPEC_PARAMS,
   3129         &TspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS))) return;
   3130 
   3131     os_error_printf(CU_MSG_INFO2, (PS8)"TSpec parameters retrieved:\nuUserPriority = %d\nuNominalMSDUsize = %d\nuMeanDataRate = %d\nuMinimumPHYRate = %d\nuSurplusBandwidthAllowance = %d\nuUAPSD_Flag = %d\nuMinimumServiceInterval = %d\nuMaximumServiceInterval = %d\nuMediumTime = %d\n",
   3132                TspecParams.uUserPriority,
   3133                TspecParams.uNominalMSDUsize,
   3134                TspecParams.uMeanDataRate,
   3135                TspecParams.uMinimumPHYRate,
   3136                TspecParams.uSurplusBandwidthAllowance,
   3137                TspecParams.uAPSDFlag,
   3138                TspecParams.uMinimumServiceInterval,
   3139                TspecParams.uMaximumServiceInterval,
   3140                TspecParams.uMediumTime);
   3141 }
   3142 
   3143 VOID CuCmd_DeleteTspec(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3144 {
   3145     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3146     OS_802_11_QOS_DELETE_TSPEC_PARAMS TspecParams;
   3147 
   3148     TspecParams.uUserPriority = parm[0].value;
   3149     TspecParams.uReasonCode = parm[1].value;
   3150 
   3151     if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_DELETE_TSPEC,
   3152         &TspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS))) return;
   3153 
   3154     os_error_printf(CU_MSG_INFO2, (PS8)"TSPEC Delete request sent to driver...\n uUserPriority = %d\n uReasonCode = %d\n",
   3155         TspecParams.uUserPriority,
   3156         TspecParams.uReasonCode);
   3157 }
   3158 
   3159 VOID CuCmd_GetApQosParams(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3160 {
   3161     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3162     OS_802_11_AC_QOS_PARAMS AcQosParams;
   3163     S32 i = 0;
   3164 
   3165     /* test if we can get the AC QOS Params */
   3166     AcQosParams.uAC = i;
   3167     if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_AP_QOS_PARAMS,
   3168         &AcQosParams, sizeof(AcQosParams))) return;
   3169 
   3170     os_error_printf(CU_MSG_INFO2, (PS8)"AP QOS Parameters:\n");
   3171     os_error_printf(CU_MSG_INFO2, (PS8)"+----+-------------+----------+-----------+-----------+-----------+\n");
   3172     os_error_printf(CU_MSG_INFO2, (PS8)"| AC | AdmCtrlFlag |   AIFS   |   CwMin   |   CwMax   | TXOPLimit |\n");
   3173     os_error_printf(CU_MSG_INFO2, (PS8)"+----+-------------+----------+-----------+-----------+-----------+\n");
   3174     os_error_printf(CU_MSG_INFO2, (PS8)"| %2d | %11d | %8d | %9d | %9d | %9d |\n",
   3175             i,
   3176             AcQosParams.uAssocAdmissionCtrlFlag,
   3177             AcQosParams.uAIFS,
   3178             AcQosParams.uCwMin,
   3179             AcQosParams.uCwMax,
   3180             AcQosParams.uTXOPLimit);
   3181 
   3182     for (i=1; i<4; i++)
   3183     {
   3184         AcQosParams.uAC = i;
   3185         if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_AP_QOS_PARAMS,
   3186             &AcQosParams, sizeof(AcQosParams))) return;
   3187 
   3188         os_error_printf(CU_MSG_INFO2, (PS8)"| %2d | %11d | %8d | %9d | %9d | %9d |\n",
   3189             i,
   3190             AcQosParams.uAssocAdmissionCtrlFlag,
   3191             AcQosParams.uAIFS,
   3192             AcQosParams.uCwMin,
   3193             AcQosParams.uCwMax,
   3194             AcQosParams.uTXOPLimit);
   3195     }
   3196     os_error_printf(CU_MSG_INFO2, (PS8)"+----+-------------+----------+-----------+-----------+-----------+\n");
   3197 }
   3198 
   3199 VOID CuCmd_GetPsRxStreamingParams(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3200 {
   3201     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3202     TPsRxStreaming tPsRxStreaming;
   3203     S32 i = 0;
   3204 
   3205     os_error_printf(CU_MSG_INFO2, (PS8)"PS Rx Streaming Parameters:\n");
   3206     os_error_printf(CU_MSG_INFO2, (PS8)"+-----+--------------+------------+---------+\n");
   3207     os_error_printf(CU_MSG_INFO2, (PS8)"| TID | StreamPeriod | uTxTimeout | Enabled |\n");
   3208     os_error_printf(CU_MSG_INFO2, (PS8)"+-----+--------------+------------+---------+\n");
   3209 
   3210     for (i=0; i<8; i++)
   3211     {
   3212         tPsRxStreaming.uTid = i;
   3213         if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, QOS_MNGR_PS_RX_STREAMING,
   3214             &tPsRxStreaming, sizeof(TPsRxStreaming))) return;
   3215 
   3216         os_error_printf(CU_MSG_INFO2, (PS8)"| %3d | %12d | %10d | %7d |\n",
   3217             tPsRxStreaming.uTid,
   3218             tPsRxStreaming.uStreamPeriod,
   3219             tPsRxStreaming.uTxTimeout,
   3220             tPsRxStreaming.bEnabled);
   3221     }
   3222     os_error_printf(CU_MSG_INFO2, (PS8)"+-----+--------------+------------+---------+\n");
   3223 }
   3224 
   3225 VOID CuCmd_GetApQosCapabilities(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3226 {
   3227     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3228 
   3229     OS_802_11_AP_QOS_CAPABILITIES_PARAMS ApQosCapabiltiesParams;
   3230 
   3231     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_AP_QOS_CAPABILITIES,
   3232         &ApQosCapabiltiesParams, sizeof(OS_802_11_AP_QOS_CAPABILITIES_PARAMS))) return;
   3233 
   3234     os_error_printf(CU_MSG_INFO2, (PS8)"AP Qos Capabilities:\n QOSFlag = %d\n APSDFlag = %d\n",
   3235         ApQosCapabiltiesParams.uQOSFlag,
   3236         ApQosCapabiltiesParams.uAPSDFlag);
   3237 
   3238 }
   3239 
   3240 VOID CuCmd_GetAcStatus(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3241 {
   3242     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3243     OS_802_11_AC_UPSD_STATUS_PARAMS AcStatusParams;
   3244 
   3245     AcStatusParams.uAC = parm[0].value;
   3246 
   3247     if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_CURRENT_AC_STATUS,
   3248         &AcStatusParams, sizeof(OS_802_11_AC_UPSD_STATUS_PARAMS))) return;
   3249 
   3250     os_error_printf(CU_MSG_INFO2, (PS8)"AC %d Status:\n", AcStatusParams.uAC);
   3251     os_error_printf(CU_MSG_INFO2, (PS8)"PS Scheme = %d (0=LEGACY, 1=UPSD)\n", AcStatusParams.uCurrentUAPSDStatus);
   3252     os_error_printf(CU_MSG_INFO2, (PS8)"Admission Status = %d (0=NOT_ADMITTED, 1=WAIT_ADMISSION, 2=ADMITTED)\n", AcStatusParams.pCurrentAdmissionStatus);
   3253 }
   3254 
   3255 VOID CuCmd_ModifyMediumUsageTh(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3256 {
   3257     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3258     OS_802_11_THRESHOLD_CROSS_PARAMS ThCrossParams;
   3259 
   3260     if (nParms == 3) /* If user supplied 3 parameters - this is a SET operation */
   3261     {
   3262         ThCrossParams.uAC = parm[0].value;
   3263         ThCrossParams.uHighThreshold = parm[1].value;
   3264         ThCrossParams.uLowThreshold = parm[2].value;
   3265 
   3266         if (ThCrossParams.uLowThreshold > ThCrossParams.uHighThreshold)
   3267         {
   3268             os_error_printf(CU_MSG_INFO2, (PS8)"Low threshold cannot be higher than the High threshold...Aborting...\n");
   3269             return;
   3270         }
   3271 
   3272         if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_MEDIUM_USAGE_THRESHOLD,
   3273             &ThCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS))) return;
   3274 
   3275         os_error_printf(CU_MSG_INFO2, (PS8)"Medium usage threshold for AC %d has been set to:\n LowThreshold = %d\n HighThreshold = %d\n",
   3276             ThCrossParams.uAC,
   3277             ThCrossParams.uLowThreshold,
   3278             ThCrossParams.uHighThreshold);
   3279    }
   3280    else if (nParms == 1) /* Only 1 parameter means a GET operation */
   3281    {
   3282         ThCrossParams.uAC = parm[0].value;
   3283         ThCrossParams.uLowThreshold = 0;
   3284         ThCrossParams.uHighThreshold = 0;
   3285 
   3286         if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_MEDIUM_USAGE_THRESHOLD,
   3287             &ThCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS))) return;
   3288 
   3289         os_error_printf(CU_MSG_INFO2, (PS8)"Medium usage threshold for AC %d:\n LowThreshold = %d\n HighThreshold = %d\n",
   3290             ThCrossParams.uAC,
   3291             ThCrossParams.uLowThreshold,
   3292             ThCrossParams.uHighThreshold);
   3293    }
   3294 }
   3295 
   3296 
   3297 VOID CuCmd_GetDesiredPsMode(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3298 {
   3299     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3300     OS_802_11_QOS_DESIRED_PS_MODE DesiredPsMode;
   3301 
   3302     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_DESIRED_PS_MODE,
   3303         &DesiredPsMode, sizeof(OS_802_11_QOS_DESIRED_PS_MODE))) return;
   3304 
   3305     os_error_printf(CU_MSG_INFO2, (PS8)"Desired PS Mode (0=PS_POLL, 1=UPSD, 2=PS_NONE):\n");
   3306     os_error_printf(CU_MSG_INFO2, (PS8)"===============================================\n");
   3307     os_error_printf(CU_MSG_INFO2, (PS8)"  +-----------+------+\n");
   3308     os_error_printf(CU_MSG_INFO2, (PS8)"  |    AC     | Mode |\n");
   3309     os_error_printf(CU_MSG_INFO2, (PS8)"  +-----------+------+\n");
   3310     os_error_printf(CU_MSG_INFO2, (PS8)"  |  General  |  %d   |\n", DesiredPsMode.uDesiredPsMode);
   3311     os_error_printf(CU_MSG_INFO2, (PS8)"  |   BE_AC   |  %d   |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BE]);
   3312     os_error_printf(CU_MSG_INFO2, (PS8)"  |   BK_AC   |  %d   |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BK]);
   3313     os_error_printf(CU_MSG_INFO2, (PS8)"  |   VI_AC   |  %d   |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VI]);
   3314     os_error_printf(CU_MSG_INFO2, (PS8)"  |   VO_AC   |  %d   |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VO]);
   3315     os_error_printf(CU_MSG_INFO2, (PS8)"  +-----------+------+\n");
   3316 }
   3317 
   3318 
   3319 VOID CuCmd_InsertClsfrEntry(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3320 {
   3321     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3322     clsfr_tableEntry_t newUserTableEntry;
   3323     S32 i;
   3324 
   3325     if (nParms >=2)
   3326         newUserTableEntry.DTag = (U8) parm[1].value;
   3327 
   3328     switch(parm[0].value)
   3329     {
   3330         case D_TAG_CLSFR:
   3331             os_error_printf(CU_MSG_INFO2, (PS8)"Cannot insert D_TAG classifier entry!\n");
   3332             return;
   3333         case DSCP_CLSFR:
   3334             if (nParms != 3)
   3335             {
   3336                 os_error_printf(CU_MSG_INFO2, (PS8)"DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n");
   3337                 return;
   3338             }
   3339             newUserTableEntry.Dscp.CodePoint = (U8) parm[2].value;
   3340             os_error_printf(CU_MSG_INFO2, (PS8)"Inserting new DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint);
   3341             break;
   3342         case PORT_CLSFR:
   3343             if (nParms != 3)
   3344             {
   3345                 os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters(too many?)\n");
   3346                 return;
   3347             }
   3348             newUserTableEntry.Dscp.DstPortNum = (U16) parm[2].value;
   3349             os_error_printf(CU_MSG_INFO2, (PS8)"Inserting new PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum);
   3350             break;
   3351         case IPPORT_CLSFR:
   3352             if (nParms != 7)
   3353             {
   3354                 os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters\n");
   3355                 return;
   3356             }
   3357             newUserTableEntry.Dscp.DstIPPort.DstPortNum = (U16) parm[2].value;
   3358             newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0;
   3359             for(i=0; i<4; i++)
   3360             {
   3361                 newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8;
   3362             }
   3363             os_error_printf(CU_MSG_INFO2, (PS8)"Inserting new IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n",
   3364                 newUserTableEntry.DTag,
   3365                 newUserTableEntry.Dscp.DstIPPort.DstPortNum,
   3366                 (S32)parm[3].value,(S32)parm[4].value,(S32)parm[5].value,(S32)parm[6].value);
   3367             break;
   3368         default:
   3369             os_error_printf(CU_MSG_INFO2, (PS8)"Unknown Classifier Type - Command aborted!\n");
   3370             return;
   3371     }
   3372 
   3373     if(CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_CONFIG_TX_CLASS,
   3374         &newUserTableEntry, sizeof(clsfr_tableEntry_t)))
   3375     {
   3376         os_error_printf(CU_MSG_INFO2, (PS8)"Failed to insert new classifier entry...\n");
   3377     }
   3378 }
   3379 
   3380 VOID CuCmd_RemoveClsfrEntry(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3381 {
   3382     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3383     clsfr_tableEntry_t newUserTableEntry;
   3384     S32 i;
   3385 
   3386     if (nParms >=2)
   3387         newUserTableEntry.DTag = (U8) parm[1].value;
   3388 
   3389     switch(parm[0].value)
   3390     {
   3391         case D_TAG_CLSFR:
   3392             os_error_printf(CU_MSG_INFO2, (PS8)"Cannot remove D_TAG classifier entry!\n");
   3393             return;
   3394         case DSCP_CLSFR:
   3395             if (nParms != 3)
   3396             {
   3397                 os_error_printf(CU_MSG_INFO2, (PS8)"DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n");
   3398                 return;
   3399             }
   3400             newUserTableEntry.Dscp.CodePoint = (U8) parm[2].value;
   3401             os_error_printf(CU_MSG_INFO2, (PS8)"Removing DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint);
   3402         break;
   3403         case PORT_CLSFR:
   3404             if (nParms != 3)
   3405             {
   3406                 os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters(too many?)\n");
   3407                 return;
   3408             }
   3409             newUserTableEntry.Dscp.DstPortNum = (U16) parm[2].value;
   3410             os_error_printf(CU_MSG_INFO2, (PS8)"Removing PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum);
   3411         break;
   3412         case IPPORT_CLSFR:
   3413             if (nParms != 7)
   3414             {
   3415                 os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters\n");
   3416                 return;
   3417             }
   3418             newUserTableEntry.Dscp.DstIPPort.DstPortNum = (U16) parm[2].value;
   3419             newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0;
   3420             for(i=0; i<4; i++)
   3421                 {
   3422                     newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8;
   3423                 }
   3424             os_error_printf(CU_MSG_INFO2, (PS8)"Removing IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n",
   3425                     newUserTableEntry.DTag,
   3426                     newUserTableEntry.Dscp.DstIPPort.DstPortNum,
   3427                     (S32)parm[3].value,(S32)parm[4].value,(S32)parm[5].value,(S32)parm[6].value);
   3428             break;
   3429         default:
   3430             os_error_printf(CU_MSG_INFO2, (PS8)"Unknown Classifier Type - Command aborted!\n");
   3431             return;
   3432         break;
   3433     }
   3434 
   3435     if(CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_REMOVE_CLSFR_ENTRY,
   3436         &newUserTableEntry, sizeof(clsfr_tableEntry_t)))
   3437     {
   3438        os_error_printf(CU_MSG_INFO2, (PS8)"Failed to remove classifier entry...\n");
   3439     }
   3440 }
   3441 
   3442 
   3443 VOID CuCmd_SetPsRxDelivery(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3444 {
   3445     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3446     TPsRxStreaming tPsRxStreaming;
   3447 
   3448     tPsRxStreaming.uTid          = parm[0].value;
   3449     tPsRxStreaming.uStreamPeriod = parm[1].value;
   3450     tPsRxStreaming.uTxTimeout    = parm[2].value;
   3451     tPsRxStreaming.bEnabled      = parm[3].value;
   3452 
   3453     if (CuCommon_SetBuffer(pCuCmd->hCuCommon, QOS_MNGR_PS_RX_STREAMING,
   3454         &tPsRxStreaming, sizeof(TPsRxStreaming)) == OK)
   3455     {
   3456         os_error_printf(CU_MSG_INFO2, (PS8)"Sent PS Rx Delivery to driver...");
   3457     }
   3458     else
   3459     {
   3460         os_error_printf(CU_MSG_INFO2, (PS8)"Error: could not set PS Rx Delivery in driver...\n");
   3461     }
   3462     os_error_printf(CU_MSG_INFO2,
   3463         (PS8)"TID = %d \n RxPeriod = %d \n TxTimeout = %d\n Enabled = %d\n",
   3464         tPsRxStreaming.uTid,
   3465         tPsRxStreaming.uStreamPeriod,
   3466         tPsRxStreaming.uTxTimeout,
   3467         tPsRxStreaming.bEnabled);
   3468 }
   3469 
   3470 
   3471 VOID CuCmd_SetQosParams(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3472 {
   3473     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3474     OS_802_11_QOS_PARAMS QosParams;
   3475 
   3476     QosParams.acID=parm[0].value;
   3477     QosParams.MaxLifeTime=parm[1].value;
   3478     QosParams.PSDeliveryProtocol = parm[2].value;
   3479 
   3480     if (CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_QOS_PARAMS,
   3481         &QosParams, sizeof(OS_802_11_QOS_PARAMS)) == OK)
   3482     {
   3483         os_error_printf(CU_MSG_INFO2, (PS8)"Sent QOS params to driver...\n AC Number=%d \n MaxLifeTime=%d \n PSDeliveryProtocol = %d\n",
   3484             QosParams.acID,
   3485             QosParams.MaxLifeTime,
   3486             QosParams.PSDeliveryProtocol);
   3487    }
   3488    else
   3489    {
   3490         os_error_printf(CU_MSG_INFO2, (PS8)"Error: could not set QOS params...\n");
   3491    }
   3492 }
   3493 
   3494 VOID CuCmd_SetRxTimeOut(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3495 {
   3496     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3497     OS_802_11_QOS_RX_TIMEOUT_PARAMS rxTimeOut;
   3498 
   3499     rxTimeOut.psPoll = parm[0].value;
   3500     rxTimeOut.UPSD   = parm[1].value;
   3501 
   3502     if (nParms != 2)
   3503     {
   3504         os_error_printf(CU_MSG_INFO2, (PS8)"Please enter Rx Time Out:\n");
   3505         os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - psPoll (0 - 65000)\n");
   3506         os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - UPSD (1 - 65000)\n");
   3507     }
   3508     else
   3509     {
   3510         if(CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_RX_TIMEOUT,
   3511             &rxTimeOut, sizeof(OS_802_11_QOS_RX_TIMEOUT_PARAMS)) == OK)
   3512         {
   3513             os_error_printf(CU_MSG_INFO2, (PS8)"Sent QOS Rx TimeOut params to driver...\n PsPoll = %d\n UPSD = %d\n",
   3514                 rxTimeOut.psPoll,
   3515                 rxTimeOut.UPSD);
   3516         }
   3517         else
   3518         {
   3519             os_error_printf(CU_MSG_INFO2, (PS8)"Error: could not set Rx TimeOut..\n");
   3520         }
   3521     }
   3522 }
   3523 
   3524 VOID CuCmd_RegisterEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3525 {
   3526     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3527 
   3528     if( nParms )
   3529     {
   3530         U32 event;
   3531         S32 res, i;
   3532 
   3533         event = (U32)parm[0].value;
   3534 
   3535         CU_CMD_FIND_NAME_ARRAY(i, event_type, event);
   3536         if(i == SIZE_ARR(event_type))
   3537         {
   3538             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %d is not defined!\n", event);
   3539             return;
   3540         }
   3541 
   3542         res = IpcEvent_EnableEvent(pCuCmd->hIpcEvent, event);
   3543         if (res == EOALERR_IPC_EVENT_ERROR_EVENT_ALREADY_ENABLED)
   3544         {
   3545             CU_CMD_FIND_NAME_ARRAY(i, event_type, event);
   3546             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %s is already enabled!\n", event_type[i].name);
   3547             return;
   3548         }
   3549 
   3550     }
   3551     else
   3552     {
   3553         print_available_values(event_type);
   3554     }
   3555 }
   3556 
   3557 VOID CuCmd_UnregisterEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3558 {
   3559     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3560 
   3561     if( nParms )
   3562     {
   3563         U32 event;
   3564         S32 res, i;
   3565 
   3566         event = (U32)parm[0].value;
   3567 
   3568         CU_CMD_FIND_NAME_ARRAY(i, event_type, event);
   3569         if(i == SIZE_ARR(event_type))
   3570         {
   3571             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %d is not defined!\n", event);
   3572             return;
   3573         }
   3574 
   3575         res = IpcEvent_DisableEvent(pCuCmd->hIpcEvent, event);
   3576         if (res == EOALERR_IPC_EVENT_ERROR_EVENT_ALREADY_DISABLED)
   3577         {
   3578             CU_CMD_FIND_NAME_ARRAY(i, event_type, event);
   3579             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %s is already disabled!\n", event_type[i].name);
   3580             return;
   3581         }
   3582 
   3583     }
   3584     else
   3585     {
   3586         print_available_values(event_type);
   3587     }
   3588 }
   3589 
   3590 VOID CuCmd_EnableBtCoe(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3591 {
   3592     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3593     ESoftGeminiEnableModes BtMode;
   3594     S32 i;
   3595 
   3596     named_value_t BtCoe_Mode[] =
   3597     {
   3598         { SG_DISABLE,       (PS8)"Disable" },
   3599         { SG_PROTECTIVE,    (PS8)"Protective" },
   3600         { SG_OPPORTUNISTIC, (PS8)"Opportunistic" },
   3601     };
   3602 
   3603 
   3604     if(nParms)
   3605     {
   3606         CU_CMD_FIND_NAME_ARRAY(i, BtCoe_Mode, parm[0].value);
   3607         if(i == SIZE_ARR(BtCoe_Mode))
   3608         {
   3609             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_EnableBtCoe, mode %d is not defined!\n", parm[0].value);
   3610             return;
   3611         }
   3612         BtMode = parm[0].value;
   3613         CuCommon_SetU32(pCuCmd->hCuCommon, SOFT_GEMINI_SET_ENABLE, BtMode);
   3614     }
   3615     else
   3616     {
   3617         print_available_values(BtCoe_Mode);
   3618     }
   3619 }
   3620 
   3621 VOID CuCmd_ConfigBtCoe(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3622 {
   3623     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3624     U32 Values[NUM_OF_CONFIG_PARAMS_IN_SG];
   3625     U8 Index;
   3626 
   3627     if( nParms != NUM_OF_CONFIG_PARAMS_IN_SG )
   3628     {
   3629 		os_error_printf(CU_MSG_INFO2, (PS8)"Please enter <index (0,1..)> <value> \n");
   3630 
   3631 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 0  - coexBtPerThreshold (0 - 10000000) PER threshold in PPM of the BT voice \n");
   3632 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 1  - coexAutoScanCompensationMaxTime (0 - 10000000 usec)  \n");
   3633 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 2  - coexBtNfsSampleInterval (1 - 65000 msec)  \n");
   3634 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 3  - coexBtLoadRatio (0 - 100 %)  \n");
   3635 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 4  - coexAutoPsMode (0 = Disabled, 1 = Enabled) Auto Power Save \n");
   3636 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 5  - coexHv3AutoScanEnlargedNumOfProbeReqPercent (%)  \n");
   3637 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 6  - coexHv3AutoScanEnlargedScanWinodowPercent (%)  \n");
   3638 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 7  - coexAntennaConfiguration (0 = Single, 1 = Dual)\n");
   3639 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 8  - coexMaxConsecutiveBeaconMissPrecent (1 - 100 %) \n");
   3640 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 9  - coexAPRateAdapationThr - rates (1 - 54)\n");
   3641 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 10 - coexAPRateAdapationSnr 	  (-128 - 127)\n");
   3642 
   3643 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 11 - coexWlanPsBtAclMasterMinBR      (msec) \n");
   3644 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 12 - coexWlanPsBtAclMasterMaxBR      (msec) \n");
   3645 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 13 - coexWlanPsMaxBtAclMasterBR      (msec) \n");
   3646 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 14 - coexWlanPsBtAclSlaveMinBR   	   (msec) \n");
   3647 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 15 - coexWlanPsBtAclSlaveMaxBR  	   (msec) \n");
   3648 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 16 - coexWlanPsMaxBtAclSlaveBR       (msec) \n");
   3649         os_error_printf(CU_MSG_INFO2, (PS8)"Param 17 - coexWlanPsBtAclMasterMinEDR     (msec) \n");
   3650 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 18 - coexWlanPsBtAclMasterMaxEDR     (msec) \n");
   3651 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 19 - coexWlanPsMaxBtAclMasterEDR     (msec) \n");
   3652 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 20 - coexWlanPsBtAclSlaveMinEDR      (msec) \n");
   3653 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 21 - coexWlanPsBtAclSlaveMaxEDR  	   (msec) \n");
   3654 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 22 - coexWlanPsMaxBtAclSlaveEDR      (msec) \n");
   3655 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 23 - coexRxt                    (usec) \n");
   3656 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 24 - coexTxt                    (usec) \n");
   3657 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 25 - coexAdaptiveRxtTxt    	  (0 = Disable, 1 = Enable) \n");
   3658 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 26 - coexPsPollTimeout          (msec) \n");
   3659 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 27 - coexUpsdTimeout       	  (msec) \n");
   3660 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 28 - coexWlanActiveBtAclMasterMinEDR (msec) \n");
   3661 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 29 - coexWlanActiveBtAclMasterMaxEDR (msec) \n");
   3662 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 30 - coexWlanActiveMaxBtAclMasterEDR (msec) \n");
   3663         os_error_printf(CU_MSG_INFO2, (PS8)"Param 31 - coexWlanActiveBtAclSlaveMinEDR  (msec) \n");
   3664 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 32 - coexWlanActiveBtAclSlaveMaxEDR  (msec) \n");
   3665 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 33 - coexWlanActiveMaxBtAclSlaveEDR  (msec) \n");
   3666 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 34 - coexWlanActiveBtAclMinBR        (msec) \n");
   3667 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 35 - coexWlanActiveBtAclMaxBR        (msec) \n");
   3668 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 36 - coexWlanActiveMaxBtAclBR        (msec) \n");
   3669         os_error_printf(CU_MSG_INFO2, (PS8)"Param 37 - coexHv3AutoEnlargePassiveScanWindowPercent \n");
   3670 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 38 - coexA2DPAutoEnlargePassiveScanWindowPercent \n");
   3671 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 39 - coexPassiveScanBtTime (msec) \n");
   3672 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 40 - coexPassiveScanWlanTime (msec)\n");
   3673 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 41 - coexTempParam5 \n");
   3674 
   3675 		return;
   3676     }
   3677     if ((parm[0].value == SOFT_GEMINI_RATE_ADAPT_THRESH) && (CuCmd_IsValueRate(parm[1].value) == FALSE))
   3678     {
   3679         os_error_printf(CU_MSG_INFO2, (PS8)"Invalid rate - PHY rate valid values are: 1,2,5,6,9,11,12,18,24,36,48,54\n");
   3680     }
   3681     else
   3682     {
   3683         for (Index = 0; Index < NUM_OF_CONFIG_PARAMS_IN_SG; Index++ )
   3684         {
   3685             Values[Index] = parm[Index].value;
   3686 /* value[0] - parmater index, value[1] - parameter value */
   3687         }
   3688         CuCommon_SetBuffer(pCuCmd->hCuCommon, SOFT_GEMINI_SET_CONFIG, Values, sizeof(Values));
   3689     }
   3690 }
   3691 
   3692 VOID CuCmd_GetBtCoeStatus(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3693 {
   3694     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3695     U32 uDummyBuf;
   3696 
   3697     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, SOFT_GEMINI_GET_CONFIG,
   3698             &uDummyBuf, sizeof(U32)))
   3699     {
   3700         return;
   3701     }
   3702 }
   3703 
   3704 VOID CuCmd_ConfigCoexActivity(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3705 {
   3706     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3707     TCoexActivity tCoexActivity;
   3708 
   3709     if( nParms != NUM_OF_COEX_ACTIVITY_PARAMS_IN_SG )
   3710     {
   3711 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - coexIp          (0 - 1) BT-0, WLAN-1 \n");
   3712 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 2 - activityId      (0 - 24)  \n");
   3713 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 3 - defaultPriority (0 - 255)  \n");
   3714 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 4 - raisedPriority  (0 - 255)  \n");
   3715 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 5 - minService      (0 - 65535)  \n");
   3716 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 6 - maxService      (0 - 65535)  \n");
   3717     }
   3718     else
   3719     {
   3720         tCoexActivity.coexIp          = (U8)parm[0].value;
   3721         tCoexActivity.activityId      = (U8)parm[1].value;
   3722         tCoexActivity.defaultPriority = (U8)parm[2].value;
   3723         tCoexActivity.raisedPriority  = (U8)parm[3].value;
   3724         tCoexActivity.minService      = (U16)parm[4].value;
   3725         tCoexActivity.maxService      = (U16)parm[5].value;
   3726 
   3727         CuCommon_SetBuffer(pCuCmd->hCuCommon, TWD_COEX_ACTIVITY_PARAM,
   3728         &tCoexActivity, sizeof(tCoexActivity));
   3729     }
   3730 }
   3731 
   3732 VOID CuCmd_ConfigFmCoex(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3733 {
   3734     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3735     TFmCoexParams tFmCoexParams;
   3736 
   3737     if (nParms != 10)
   3738     {
   3739 		os_error_printf(CU_MSG_INFO2, (PS8)"1 - Enable                   (0 - 1)  \n");
   3740 		os_error_printf(CU_MSG_INFO2, (PS8)"2 - SwallowPeriod            (0 - 255)  \n");
   3741 		os_error_printf(CU_MSG_INFO2, (PS8)"3 - NDividerFrefSet1         (0 - 255)  \n");
   3742 		os_error_printf(CU_MSG_INFO2, (PS8)"4 - NDividerFrefSet2         (0 - 255)  \n");
   3743 		os_error_printf(CU_MSG_INFO2, (PS8)"5 - MDividerFrefSet1         (0 - 65535)  \n");
   3744 		os_error_printf(CU_MSG_INFO2, (PS8)"6 - MDividerFrefSet2         (0 - 65535)  \n");
   3745 		os_error_printf(CU_MSG_INFO2, (PS8)"7 - CoexPllStabilizationTime (0 - 4294967295)  \n");
   3746 		os_error_printf(CU_MSG_INFO2, (PS8)"8 - LdoStabilizationTime     (0 - 65535)  \n");
   3747 		os_error_printf(CU_MSG_INFO2, (PS8)"9 - FmDisturbedBandMargin    (0 - 255)  \n");
   3748 		os_error_printf(CU_MSG_INFO2, (PS8)"10- SwallowClkDif            (0 - 255)  \n");
   3749     }
   3750     else
   3751     {
   3752         tFmCoexParams.uEnable                    = (TI_UINT8)parm[0].value;
   3753         tFmCoexParams.uSwallowPeriod             = (TI_UINT8)parm[1].value;
   3754         tFmCoexParams.uNDividerFrefSet1          = (TI_UINT8)parm[2].value;
   3755         tFmCoexParams.uNDividerFrefSet2          = (TI_UINT8)parm[3].value;
   3756         tFmCoexParams.uMDividerFrefSet1          = (TI_UINT16)parm[4].value;
   3757         tFmCoexParams.uMDividerFrefSet2          = (TI_UINT16)parm[5].value;
   3758         tFmCoexParams.uCoexPllStabilizationTime  = parm[6].value;
   3759         tFmCoexParams.uLdoStabilizationTime      = (TI_UINT16)parm[7].value;
   3760         tFmCoexParams.uFmDisturbedBandMargin     = (TI_UINT8)parm[8].value;
   3761         tFmCoexParams.uSwallowClkDif             = (TI_UINT8)parm[9].value;
   3762 
   3763         CuCommon_SetBuffer(pCuCmd->hCuCommon, TWD_FM_COEX_PARAM, &tFmCoexParams, sizeof(TFmCoexParams));
   3764     }
   3765 }
   3766 
   3767 VOID CuCmd_SetPowerMode(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3768 {
   3769     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3770     TPowerMgr_PowerMode Mode;
   3771     S32 i;
   3772 
   3773     if( nParms )
   3774     {
   3775         CU_CMD_FIND_NAME_ARRAY(i, power_mode_val, parm[0].value);
   3776         if(i == SIZE_ARR(power_mode_val))
   3777         {
   3778             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPowerMode, mode %d is not defined!\n", parm[0].value);
   3779             return;
   3780         }
   3781         Mode.PowerMode = parm[0].value;
   3782         Mode.PowerMngPriority = POWER_MANAGER_USER_PRIORITY;
   3783         CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_SET,
   3784             &Mode, sizeof(TPowerMgr_PowerMode));
   3785     }
   3786     else
   3787     {
   3788         if(!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET, &Mode, sizeof(TPowerMgr_PowerMode)))
   3789         {
   3790             os_error_printf(CU_MSG_INFO2, (PS8)"Power mode: %d\n", Mode.PowerMode);
   3791             print_available_values(power_mode_val);
   3792         }
   3793     }
   3794 }
   3795 
   3796 VOID CuCmd_SetPowerSavePowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3797 {
   3798     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3799     U32 PowerSavePowerLevel;
   3800     S32 i;
   3801 
   3802     if( nParms )
   3803     {
   3804         CU_CMD_FIND_NAME_ARRAY(i, power_level, parm[0].value);
   3805         if(i == SIZE_ARR(power_level))
   3806         {
   3807             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPowerSavePowerLevel, level %d is not defined!\n", parm[0].value);
   3808             return;
   3809         }
   3810         PowerSavePowerLevel = parm[0].value;
   3811         CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_PS_SET, PowerSavePowerLevel);
   3812     }
   3813     else
   3814     {
   3815         if(!CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_PS_GET, &PowerSavePowerLevel))
   3816         {
   3817             CU_CMD_FIND_NAME_ARRAY(i, power_level, PowerSavePowerLevel);
   3818             os_error_printf(CU_MSG_INFO2, (PS8)"Power Level PowerSave is: %s\n", power_level[i].name);
   3819             print_available_values(power_level);
   3820         }
   3821     }
   3822 }
   3823 
   3824 VOID CuCmd_SetDefaultPowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3825 {
   3826     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3827     U32 DefaultPowerLevel;
   3828     S32 i;
   3829 
   3830     if( nParms )
   3831     {
   3832         CU_CMD_FIND_NAME_ARRAY(i, power_level, parm[0].value);
   3833         if(i == SIZE_ARR(power_level))
   3834         {
   3835             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetDefaultPowerLevel, level %d is not defined!\n", parm[0].value);
   3836             return;
   3837         }
   3838         DefaultPowerLevel = parm[0].value;
   3839         CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DEFAULT_SET, DefaultPowerLevel);
   3840     }
   3841     else
   3842     {
   3843         if(!CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DEFAULT_GET, &DefaultPowerLevel))
   3844         {
   3845             CU_CMD_FIND_NAME_ARRAY(i, power_level, DefaultPowerLevel);
   3846             os_error_printf(CU_MSG_INFO2, (PS8)"Power Level Default is: %s\n", power_level[i].name);
   3847             print_available_values(power_level);
   3848         }
   3849     }
   3850 }
   3851 
   3852 VOID CuCmd_SetDozeModeInAutoPowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3853 {
   3854     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3855     U32 DozeModeInAutoPowerLevel;
   3856     S32 i;
   3857 
   3858     if( nParms )
   3859     {
   3860         DozeModeInAutoPowerLevel = parm[0].value;
   3861 
   3862         if((DozeModeInAutoPowerLevel > AUTO_POWER_MODE_DOZE_MODE_MAX_VALUE) || (DozeModeInAutoPowerLevel < AUTO_POWER_MODE_DOZE_MODE_MIN_VALUE))
   3863         {
   3864             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetDozeModeInAutoPowerLevel, level %d is not defined!\n", DozeModeInAutoPowerLevel);
   3865             return;
   3866         }
   3867         CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DOZE_MODE_SET, DozeModeInAutoPowerLevel);
   3868     }
   3869     else
   3870     {
   3871         /* set Short or Long Doze. no use of other parameters */
   3872         if(!CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DOZE_MODE_GET, &DozeModeInAutoPowerLevel))
   3873         {
   3874             CU_CMD_FIND_NAME_ARRAY(i, power_mode_val, DozeModeInAutoPowerLevel);
   3875             os_error_printf(CU_MSG_INFO2, (PS8)"Doze power level in auto mode is: %s\n", power_mode_val[i].name);
   3876         }
   3877     }
   3878 }
   3879 
   3880 VOID CuCmd_SetTrafficIntensityTh(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3881 {
   3882     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3883     OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS TrafficIntensityTh;
   3884 
   3885     if (nParms == 3)
   3886     {
   3887         TrafficIntensityTh.uHighThreshold = parm[0].value;
   3888         TrafficIntensityTh.uLowThreshold = parm[1].value;
   3889         TrafficIntensityTh.TestInterval = parm[2].value;
   3890 
   3891         if (TrafficIntensityTh.uLowThreshold >= TrafficIntensityTh.uHighThreshold)
   3892         {
   3893             os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetTrafficIntensityTh - low threshold equal or greater than the high threshold...aborting...\n");
   3894         }
   3895 
   3896         if(OK == CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_TRAFFIC_INTENSITY_THRESHOLDS,
   3897             &TrafficIntensityTh, sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS)))
   3898         {
   3899             os_error_printf(CU_MSG_INFO2, (PS8)"Successfully set traffic intensity thresholds...\n");
   3900         }
   3901         else
   3902         {
   3903             os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetTrafficIntensityTh - cannot set thresholds\n");
   3904         }
   3905     }
   3906     else if (nParms == 0)
   3907     {
   3908         if(OK == CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_TRAFFIC_INTENSITY_THRESHOLDS,
   3909             &TrafficIntensityTh, sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS)))
   3910         {
   3911             os_error_printf(CU_MSG_INFO2, (PS8)"Traffic intensity thresholds :\n HighThreshold = %d\n LowThreshold = %d\n TestInterval = %d\n",
   3912                   TrafficIntensityTh.uHighThreshold,
   3913                   TrafficIntensityTh.uLowThreshold,
   3914                   TrafficIntensityTh.TestInterval);
   3915         }
   3916         else
   3917         {
   3918             os_error_printf (CU_MSG_ERROR, (PS8)"Error - CuCmd_SetTrafficIntensityTh - cannot get thresholds\n");
   3919         }
   3920     }
   3921 }
   3922 
   3923 VOID CuCmd_EnableTrafficEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3924 {
   3925     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3926     if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_TOGGLE_TRAFFIC_INTENSITY_EVENTS, TRUE) ) return;
   3927     os_error_printf(CU_MSG_INFO2, (PS8)"Traffic intensity thresholds enabled...\n");
   3928 }
   3929 
   3930 VOID CuCmd_DisableTrafficEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3931 {
   3932     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3933     if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_TOGGLE_TRAFFIC_INTENSITY_EVENTS, FALSE) ) return;
   3934     os_error_printf(CU_MSG_INFO2, (PS8)"Traffic intensity thresholds disabled...\n");
   3935 }
   3936 
   3937 VOID CuCmd_SetDcoItrimParams(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3938 {
   3939     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3940     DcoItrimParams_t dcoItrimParams;
   3941 
   3942     if (nParms == 0)
   3943     {
   3944         if (OK == CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_DCO_ITRIM_PARAMS, &dcoItrimParams, sizeof(DcoItrimParams_t)))
   3945         {
   3946             os_error_printf(CU_MSG_INFO2, (PS8)"DCO Itrim Params :\n enable = %d\n moderationTimeoutUsec = %d\n",
   3947                             dcoItrimParams.enable, dcoItrimParams.moderationTimeoutUsec);
   3948         }
   3949         else
   3950         {
   3951             os_error_printf (CU_MSG_ERROR, (PS8)"Error - CuCmd_SetDcoItrimParams - cannot get DCO Itrim Params\n");
   3952         }
   3953     }
   3954 
   3955     else
   3956     {
   3957         dcoItrimParams.enable = (Bool_e)parm[0].value;
   3958         dcoItrimParams.moderationTimeoutUsec = parm[1].value;
   3959 
   3960         if (OK == CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_DCO_ITRIM_PARAMS, &dcoItrimParams, sizeof(DcoItrimParams_t)))
   3961         {
   3962             os_error_printf(CU_MSG_INFO2, (PS8)"Successfully set DCO Itrim Params...\n");
   3963         }
   3964         else
   3965         {
   3966             os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetDcoItrimParams - cannot set DCO Itrim Params\n");
   3967         }
   3968     }
   3969 }
   3970 
   3971 VOID CuCmd_LogAddReport(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3972 {
   3973     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3974     U8 ModuleTable[REPORT_FILES_NUM], ModuleValue[REPORT_FILES_NUM] = {0};
   3975     int index = 0;
   3976 
   3977     os_memcpy((THandle)ModuleValue, (THandle)(parm[0].value), nParms);
   3978 
   3979     for (index = 0; index < REPORT_FILES_NUM; index ++)
   3980     {
   3981         if (ModuleValue[index] == '1')
   3982         {
   3983             ModuleTable[index] = '1';
   3984         }
   3985         else
   3986         {
   3987             ModuleTable[index] = '0';
   3988         }
   3989     }
   3990     CuCommon_SetBuffer(pCuCmd->hCuCommon, REPORT_MODULE_TABLE_PARAM, ModuleTable, REPORT_FILES_NUM);
   3991 }
   3992 
   3993 VOID CuCmd_LogReportSeverityLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   3994 {
   3995     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   3996     U8 SeverityTable[REPORT_SEVERITY_MAX];
   3997     S32 index = 0;
   3998     PS8 SeverityValue = (PS8)(parm[0].value);
   3999 
   4000     /* Get the current report severity */
   4001     if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, REPORT_SEVERITY_TABLE_PARAM, SeverityTable, REPORT_SEVERITY_MAX))
   4002     {
   4003         if(nParms == 0)
   4004         {
   4005             S32 i;
   4006 
   4007             os_error_printf(CU_MSG_INFO2, (PS8)"Severity:\n");
   4008             os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n");
   4009             os_error_printf(CU_MSG_INFO2, (PS8)"%14s\tState\t%s\n", (PS8)"Severity level", (PS8)"Desc");
   4010 
   4011             for( i=1; i<SIZE_ARR(report_severity); i++ )
   4012             {
   4013                 os_error_printf(CU_MSG_INFO2, (PS8)"%d\t%c\t%s\n", report_severity[i].value, (SeverityTable[i] == '1') ? '+' : ' ', report_severity[i].name );
   4014             }
   4015 
   4016             os_error_printf(CU_MSG_INFO2, (PS8)"* Use '0' to clear all table.\n");
   4017             os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to set all table.\n", REPORT_SEVERITY_MAX);
   4018         }
   4019         else
   4020         {
   4021             for (index = 0; index < REPORT_SEVERITY_MAX; index ++)
   4022             {
   4023                 if (SeverityValue[index] == '0')
   4024                 {
   4025                     SeverityTable[index] = '0';
   4026                 }
   4027                 else
   4028                 {
   4029                     SeverityTable[index] = '1';
   4030                 }
   4031             }
   4032             CuCommon_SetBuffer(pCuCmd->hCuCommon, REPORT_SEVERITY_TABLE_PARAM, SeverityTable, REPORT_SEVERITY_MAX);
   4033         }
   4034     }
   4035     else
   4036     {
   4037         os_error_printf(CU_MSG_ERROR, (PS8)"Error retriving the severity table from the driver\n");
   4038     }
   4039 }
   4040 
   4041 VOID CuCmd_SetReport(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4042 {
   4043     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4044     U8 *pModuleTable = (U8 *)parm[0].value;
   4045 
   4046     if( nParms != 1)
   4047     {
   4048         U8 ModuleTable[REPORT_FILES_NUM];
   4049         S32 i;
   4050 
   4051         if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM))
   4052         {
   4053             os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n");
   4054             os_error_printf(CU_MSG_INFO2, (PS8)"%.5s\tState\t %s\n", (PS8)"Index", (PS8)"Desc");
   4055 
   4056             for( i = 0; i < SIZE_ARR(report_module); i++)
   4057             {
   4058                 /* Check if there is string content (the first character is not ZERO) */
   4059                 if( report_module[i].name[0] )
   4060                 {
   4061                     U8 module_num = (U8) report_module[i].value;
   4062                     os_error_printf(CU_MSG_INFO2, (PS8)"%3d\t%c\t%s\n",
   4063                          module_num,
   4064                          (ModuleTable[module_num] == '1') ? '+' : ' ',
   4065                          report_module[i].name );
   4066                 }
   4067             }
   4068         }
   4069         else
   4070         {
   4071             os_error_printf(CU_MSG_ERROR, (PS8)"Error reading the report table form the driver\n");
   4072         }
   4073     }
   4074     else
   4075     {
   4076         CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_SET, pModuleTable, REPORT_FILES_NUM);
   4077     }
   4078 }
   4079 
   4080 VOID CuCmd_AddReport(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4081 {
   4082     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4083     U8 ModuleTable[REPORT_FILES_NUM];
   4084 
   4085     if( nParms != 1)
   4086     {
   4087         S32 i;
   4088         if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM))
   4089         {
   4090             os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n");
   4091             os_error_printf(CU_MSG_INFO2, (PS8)"%.5s\tState\t %s\n", (PS8)"Index", (PS8)"Desc");
   4092 
   4093             for( i = 0; i < SIZE_ARR(report_module); i++)
   4094             {
   4095                 /* Check if there is string content (the first character is not ZERO) */
   4096                 if( report_module[i].name[0] )
   4097                 {
   4098                     os_error_printf(CU_MSG_INFO2, (PS8)"%3d\t%c\t%s\n", report_module[i].value, (ModuleTable[i] == '1') ? '+' : ' ', report_module[i].name );
   4099                 }
   4100             }
   4101         }
   4102         else
   4103         {
   4104             os_error_printf(CU_MSG_ERROR, (PS8)"Error reading the report table form the driver\n");
   4105         }
   4106         os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to set all table.\n", REPORT_FILES_NUM);
   4107     }
   4108     else if(!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM))
   4109     {
   4110         if (parm[0].value == REPORT_FILES_NUM)
   4111         {
   4112             os_memset(ModuleTable, '1', REPORT_FILES_NUM);
   4113         }
   4114         else if(parm[0].value < REPORT_FILES_NUM)
   4115         {
   4116             ModuleTable[parm[0].value] = '1';
   4117         }
   4118         CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_SET, ModuleTable, REPORT_FILES_NUM);
   4119     }
   4120 }
   4121 
   4122 VOID CuCmd_ClearReport(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4123 {
   4124     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4125     U8 ModuleTable[REPORT_FILES_NUM];
   4126 
   4127     if( nParms != 1)
   4128     {
   4129         S32 i;
   4130         if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM))
   4131         {
   4132             os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n");
   4133             os_error_printf(CU_MSG_INFO2, (PS8)"%.5s\tState\t %s\n", (PS8)"Index", (PS8)"Desc");
   4134 
   4135             for( i = 0; i < SIZE_ARR(report_module); i++)
   4136             {
   4137                 /* Check if there is string content (the first character is not ZERO) */
   4138                 if( report_module[i].name[0] )
   4139                 {
   4140                     os_error_printf(CU_MSG_INFO2, (PS8)"%3d\t%c\t%s\n", report_module[i].value, (ModuleTable[i] == '1') ? '+' : ' ', report_module[i].name );
   4141                 }
   4142             }
   4143         }
   4144         else
   4145         {
   4146             os_error_printf(CU_MSG_ERROR, (PS8)"Error reading the report table form the driver\n");
   4147         }
   4148         os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to clear all table.\n", REPORT_FILES_NUM);
   4149     }
   4150     else if(!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM))
   4151     {
   4152         if (parm[0].value == REPORT_FILES_NUM)
   4153         {
   4154             os_memset(ModuleTable, '0', REPORT_FILES_NUM);
   4155         }
   4156         else if(parm[0].value < REPORT_FILES_NUM)
   4157         {
   4158             ModuleTable[parm[0].value] = '0';
   4159         }
   4160         CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_SET, ModuleTable, REPORT_FILES_NUM);
   4161     }
   4162 }
   4163 
   4164 VOID CuCmd_ReportSeverityLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4165 {
   4166     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4167     U8 SeverityTable[REPORT_SEVERITY_MAX];
   4168 
   4169     /* Get the current report severity */
   4170     if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_GET, SeverityTable, REPORT_SEVERITY_MAX))
   4171     {
   4172         if(nParms == 0)
   4173         {
   4174             S32 i;
   4175 
   4176             os_error_printf(CU_MSG_INFO2, (PS8)"Severity:\n");
   4177             os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n");
   4178             os_error_printf(CU_MSG_INFO2, (PS8)"%14s\tState\t%s\n", (PS8)"Severity level", (PS8)"Desc");
   4179 
   4180             for( i=1; i<SIZE_ARR(report_severity); i++ )
   4181             {
   4182                 os_error_printf(CU_MSG_INFO2, (PS8)"%d\t%c\t%s\n", report_severity[i].value, (SeverityTable[i] == '1') ? '+' : ' ', report_severity[i].name );
   4183             }
   4184 
   4185             os_error_printf(CU_MSG_INFO2, (PS8)"* Use '0' to clear all table.\n");
   4186             os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to set all table.\n", REPORT_SEVERITY_MAX);
   4187         }
   4188         else
   4189         {
   4190             if (parm[0].value == 0)
   4191             {
   4192                 /* Disable all severity levels */
   4193                 os_memset(SeverityTable, '0', sizeof(SeverityTable));
   4194                 CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_SET, SeverityTable, REPORT_SEVERITY_MAX);
   4195             }
   4196             else if (parm[0].value == REPORT_SEVERITY_MAX)
   4197             {
   4198                 /* Enable all severity levels */
   4199                 os_memset(SeverityTable, '1', sizeof(SeverityTable));
   4200                 CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_SET, SeverityTable, REPORT_SEVERITY_MAX);
   4201             }
   4202             else if (parm[0].value < REPORT_SEVERITY_MAX)
   4203             {
   4204                 os_error_printf(CU_MSG_INFO2, (PS8)"Toggle severity level %#lx\n", parm[0].value);
   4205                 if (SeverityTable[parm[0].value] == '1')
   4206                 {
   4207                     /* The level is enabled - Disable it */
   4208                     SeverityTable[parm[0].value] = '0';
   4209                 }
   4210                 else
   4211                 {
   4212                     /* The bit is disabled - Enable it */
   4213                     SeverityTable[parm[0].value] = '1';
   4214                 }
   4215                 CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_SET, SeverityTable, REPORT_SEVERITY_MAX);
   4216             }
   4217             else
   4218             {
   4219                 os_error_printf(CU_MSG_INFO2, (PS8)"invalid level value: %#lx\n", parm[0].value );
   4220             }
   4221         }
   4222     }
   4223     else
   4224     {
   4225         os_error_printf(CU_MSG_ERROR, (PS8)"Error retriving the severity table from the driver\n");
   4226     }
   4227 }
   4228 
   4229 VOID CuCmd_SetReportLevelCLI(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4230 {
   4231 #if 0 /* need to create debug logic for CLI */
   4232     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4233     S32 i, cli_debug_level;
   4234 
   4235     if(nParms)
   4236     {
   4237         cli_debug_level = parm[0].value;
   4238         /* check if the param is valid */
   4239         CU_CMD_FIND_NAME_ARRAY(i, cli_level_type, cli_debug_level);
   4240         if(i == SIZE_ARR(cli_level_type))
   4241         {
   4242             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetReportLevelCLI, cli_debug_level %d is not defined!\n", cli_debug_level);
   4243             return;
   4244         }
   4245 
   4246         g_debug_level = cli_debug_level;
   4247         IpcEvent_UpdateDebugLevel(pCuCmd->hIpcEvent, cli_debug_level);
   4248         os_error_printf(CU_MSG_INFO2, (PS8)"set CLI debug value = %s \n", cli_level_type[i].name);
   4249     }
   4250     else
   4251     {
   4252         cli_debug_level = g_debug_level;
   4253         CU_CMD_FIND_NAME_ARRAY(i, cli_level_type, cli_debug_level);
   4254         os_error_printf(CU_MSG_INFO2, (PS8)"CLI debug value = %s (%d)\n", cli_level_type[i].name, cli_debug_level);
   4255         print_available_values(cli_level_type);
   4256     }
   4257 #endif
   4258 }
   4259 
   4260 
   4261 char* SkipSpaces(char* str)
   4262 {
   4263 	char* tmp = str;
   4264 
   4265 	while(*tmp == ' ') tmp++;
   4266 	return tmp;
   4267 }
   4268 
   4269 #define ti_isdigit(c)      ('0' <= (c) && (c) <= '9')
   4270 #define ti_islower(c)      ('a' <= (c) && (c) <= 'z')
   4271 #define ti_toupper(c)      (ti_islower(c) ? ((c) - 'a' + 'A') : (c))
   4272 
   4273 #define ti_isxdigit(c)   (('0' <= (c) && (c) <= '9') \
   4274                          || ('a' <= (c) && (c) <= 'f') \
   4275                          || ('A' <= (c) && (c) <= 'F'))
   4276 
   4277 #define ti_atol(x) strtoul(x, 0)
   4278 
   4279 
   4280 unsigned long ti_strtoul(char *cp, char** endp, unsigned int base)
   4281 {
   4282 	unsigned long result = 0, value;
   4283 
   4284 	if (!base) {
   4285 		  base = 10;
   4286 		  if (*cp == '0') {
   4287 				  base = 8;
   4288 				  cp++;
   4289 				  if ((ti_toupper(*cp) == 'X') && ti_isxdigit(cp[1])) {
   4290 						  cp++;
   4291 						  base = 16;
   4292 				  }
   4293 		  }
   4294 	} else if (base == 16) {
   4295 		  if (cp[0] == '0' && ti_toupper(cp[1]) == 'X')
   4296 				  cp += 2;
   4297 	}
   4298 	while (ti_isxdigit(*cp) &&
   4299 			(value = ti_isdigit(*cp) ? *cp-'0' : ti_toupper(*cp)-'A'+10) < base) {
   4300 			result = result*base + value;
   4301 			 cp++;
   4302 	}
   4303 
   4304 	if(endp)
   4305 		*endp = (char *)cp;
   4306 
   4307 	return result;
   4308 }
   4309 
   4310 
   4311 VOID CuCmd_FwDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4312 {
   4313 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4314 	U32 *buf_ptr, *pbuf;
   4315 	char *pstr = (char *)parm[0].value;
   4316 	U32 parm_length;
   4317 
   4318 	os_error_printf(CU_MSG_INFO2, (PS8)"FwDebug parm: %s\n", parm[0].value);
   4319 
   4320 	buf_ptr = (U32*)os_MemoryCAlloc(252, sizeof(U32));
   4321 	if(!buf_ptr)
   4322 		return;
   4323 
   4324 	pbuf = buf_ptr + 2;
   4325 
   4326 	pstr = SkipSpaces(pstr);
   4327 	while(*pstr) {
   4328 		*pbuf++ =  ti_strtoul(pstr, &pstr, 0);
   4329 		pstr = SkipSpaces(pstr);
   4330 	}
   4331 
   4332 	parm_length = (U32)((U8*)pbuf-(U8*)buf_ptr);
   4333 
   4334 	os_error_printf(CU_MSG_INFO2, (PS8)"Parms buf size = %d\n", parm_length);
   4335 
   4336 	*buf_ptr = 2210;
   4337 	*(buf_ptr+1) = parm_length - 2*sizeof(U32);
   4338 
   4339 	CuCommon_PrintDriverDebug(pCuCmd->hCuCommon, (PVOID)buf_ptr, parm_length);
   4340 
   4341 	os_MemoryFree(buf_ptr);
   4342 
   4343 }
   4344 
   4345 VOID CuCmd_SetRateMngDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4346 {
   4347     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4348     RateMangeParams_t     RateParams;
   4349 
   4350 	RateParams.paramIndex = (TI_UINT8)parm[0].value;
   4351 
   4352 
   4353     if( nParms == 2 )
   4354     {
   4355 		switch (RateParams.paramIndex)
   4356 		{
   4357 		case RATE_MGMT_RETRY_SCORE_PARAM:
   4358 			RateParams.RateRetryScore = (TI_UINT16)parm[1].value;
   4359 			break;
   4360 		case RATE_MGMT_PER_ADD_PARAM:
   4361 			RateParams.PerAdd = (TI_UINT16)parm[1].value;
   4362 			break;
   4363 		case RATE_MGMT_PER_TH1_PARAM:
   4364 			RateParams.PerTh1 = (TI_UINT16)parm[1].value;
   4365 			break;
   4366 		case RATE_MGMT_PER_TH2_PARAM:
   4367 			RateParams.PerTh2 = (TI_UINT16)parm[1].value;
   4368 			break;
   4369 		case RATE_MGMT_MAX_PER_PARAM:
   4370 			RateParams.MaxPer = (TI_UINT16)parm[1].value;
   4371 			break;
   4372 		case RATE_MGMT_INVERSE_CURIOSITY_FACTOR_PARAM:
   4373 			RateParams.InverseCuriosityFactor = (TI_UINT8)parm[1].value;
   4374 			break;
   4375 		case RATE_MGMT_TX_FAIL_LOW_TH_PARAM:
   4376 			RateParams.TxFailLowTh = (TI_UINT8)parm[1].value;
   4377 			break;
   4378 		case RATE_MGMT_TX_FAIL_HIGH_TH_PARAM:
   4379 			RateParams.TxFailHighTh = (TI_UINT8)parm[1].value;
   4380 			break;
   4381 		case RATE_MGMT_PER_ALPHA_SHIFT_PARAM:
   4382 			RateParams.PerAlphaShift = (TI_UINT8)parm[1].value;
   4383 			break;
   4384 		case RATE_MGMT_PER_ADD_SHIFT_PARAM:
   4385 			RateParams.PerAddShift = (TI_UINT8)parm[1].value;
   4386 			break;
   4387 		case RATE_MGMT_PER_BETA1_SHIFT_PARAM:
   4388 			RateParams.PerBeta1Shift = (TI_UINT8)parm[1].value;
   4389 			break;
   4390 		case RATE_MGMT_PER_BETA2_SHIFT_PARAM:
   4391 			RateParams.PerBeta2Shift = (TI_UINT8)parm[1].value;
   4392 			break;
   4393 		case RATE_MGMT_RATE_CHECK_UP_PARAM:
   4394 			RateParams.RateCheckUp = (TI_UINT8)parm[1].value;
   4395 			break;
   4396 		case RATE_MGMT_RATE_CHECK_DOWN_PARAM:
   4397 			RateParams.RateCheckDown = (TI_UINT8)parm[1].value;
   4398 			break;
   4399 		default:
   4400 			os_error_printf(CU_MSG_INFO2,"Error: index is not valid! \n");
   4401 			return;
   4402 
   4403 		}
   4404 	}
   4405 	else if ((nParms == NUM_OF_RATE_MNGT_PARAMS_MAX) && (parm[0].value == RATE_MGMT_RATE_RETRY_POLICY_PARAM ))
   4406 	{
   4407 		int i=0;
   4408 		for (i=1; i < NUM_OF_RATE_MNGT_PARAMS_MAX; i++)
   4409 		{
   4410 			RateParams.RateRetryPolicy[i-1] = (TI_UINT8)parm[i].value;
   4411 		}
   4412     }
   4413     else
   4414     {
   4415            os_error_printf(CU_MSG_INFO2,"(0)  RateMngRateRetryScore \n");
   4416            os_error_printf(CU_MSG_INFO2,"(1)  RateMngPerAdd \n");
   4417            os_error_printf(CU_MSG_INFO2,"(2)  RateMngPerTh1 \n");
   4418            os_error_printf(CU_MSG_INFO2,"(3)  RateMngPerTh2 \n");
   4419 		   os_error_printf(CU_MSG_INFO2,"(4)  RateMngMaxPer \n");
   4420            os_error_printf(CU_MSG_INFO2,"(5)  RateMngInverseCuriosityFactor \n");
   4421            os_error_printf(CU_MSG_INFO2,"(6)  RateMngTxFailLowTh \n");
   4422 		   os_error_printf(CU_MSG_INFO2,"(7)  RateMngTxFailHighTh \n");
   4423            os_error_printf(CU_MSG_INFO2,"(8)  RateMngPerAlphaShift \n");
   4424            os_error_printf(CU_MSG_INFO2,"(9)  RateMngPerAddShift \n");
   4425            os_error_printf(CU_MSG_INFO2,"(10) RateMngPerBeta1Shift \n");
   4426            os_error_printf(CU_MSG_INFO2,"(11) RateMngPerBeta2Shift \n");
   4427            os_error_printf(CU_MSG_INFO2,"(12) RateMngRateCheckUp \n");
   4428 		   os_error_printf(CU_MSG_INFO2,"(13) RateMngRateCheckDown \n");
   4429 		   os_error_printf(CU_MSG_INFO2,"(14) RateMngRateRetryPolicy[13] \n");
   4430 		   return;
   4431     }
   4432 
   4433 	CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_RATE_MNG_SET,&RateParams, sizeof(RateMangeParams_t));
   4434 }
   4435 
   4436 VOID CuCmd_GetRateMngDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4437 {
   4438     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4439     AcxRateMangeParams ReadRateParams;
   4440 	int i;
   4441 
   4442     os_memset(&ReadRateParams,0,sizeof(AcxRateMangeParams));
   4443 
   4444     CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_RATE_MNG_GET, &ReadRateParams, sizeof(AcxRateMangeParams));
   4445 
   4446 	if (0 == nParms)
   4447 	{
   4448 		parm[0].value =  RATE_MGMT_ALL_PARAMS;
   4449 	}
   4450 
   4451 	 switch (parm[0].value)
   4452 		{
   4453 		case RATE_MGMT_RETRY_SCORE_PARAM:
   4454 			os_error_printf(CU_MSG_INFO2,"RateMngRateRetryScore = %d \n", ReadRateParams.RateRetryScore);
   4455 			break;
   4456 		case RATE_MGMT_PER_ADD_PARAM:
   4457 			os_error_printf(CU_MSG_INFO2,"RateMngPerAdd = %d\n" , ReadRateParams.PerAdd);
   4458 			break;
   4459 		case RATE_MGMT_PER_TH1_PARAM:
   4460 			os_error_printf(CU_MSG_INFO2,"RateMngPerTh1 = %d\n" , ReadRateParams.PerTh1);
   4461 			break;
   4462 		case RATE_MGMT_PER_TH2_PARAM:
   4463 			os_error_printf(CU_MSG_INFO2,"RateMngPerTh2 = %d\n" , ReadRateParams.PerTh2);
   4464 			break;
   4465 		case RATE_MGMT_MAX_PER_PARAM:
   4466 			os_error_printf(CU_MSG_INFO2,"RateMngMaxPer = %d\n" , ReadRateParams.MaxPer);
   4467 			break;
   4468 		case RATE_MGMT_INVERSE_CURIOSITY_FACTOR_PARAM:
   4469 			os_error_printf(CU_MSG_INFO2,"RateMngInverseCuriosityFactor = %d \n" , ReadRateParams.InverseCuriosityFactor);
   4470 			break;
   4471 		case RATE_MGMT_TX_FAIL_LOW_TH_PARAM:
   4472 			os_error_printf(CU_MSG_INFO2,"RateMngTxFailLowTh = %d\n" , ReadRateParams.TxFailLowTh);
   4473 			break;
   4474 		case RATE_MGMT_TX_FAIL_HIGH_TH_PARAM:
   4475 			os_error_printf(CU_MSG_INFO2,"RateMngTxFailHighTh = %d\n" , ReadRateParams.TxFailHighTh);
   4476 			break;
   4477 		case RATE_MGMT_PER_ALPHA_SHIFT_PARAM:
   4478 			os_error_printf(CU_MSG_INFO2,"RateMngPerAlphaShift = %d\n" , ReadRateParams.PerAlphaShift);
   4479 			break;
   4480 		case RATE_MGMT_PER_ADD_SHIFT_PARAM:
   4481 			os_error_printf(CU_MSG_INFO2,"RateMngPerAddShift = %d\n" , ReadRateParams.PerAddShift);
   4482 			break;
   4483 		case RATE_MGMT_PER_BETA1_SHIFT_PARAM:
   4484 			os_error_printf(CU_MSG_INFO2,"RateMngPerBeta1Shift = %d\n" , ReadRateParams.PerBeta1Shift);
   4485 			break;
   4486 		case RATE_MGMT_PER_BETA2_SHIFT_PARAM:
   4487 			os_error_printf(CU_MSG_INFO2,"RateMngPerBeta2Shift = %d\n" , ReadRateParams.PerBeta2Shift);
   4488 			break;
   4489 		case RATE_MGMT_RATE_CHECK_UP_PARAM:
   4490 			os_error_printf(CU_MSG_INFO2,"RateMngRateCheckUp = %d\n" , ReadRateParams.RateCheckUp);
   4491 			break;
   4492 		case RATE_MGMT_RATE_CHECK_DOWN_PARAM:
   4493 			os_error_printf(CU_MSG_INFO2,"RateMngRateCheckDown = %d\n" , ReadRateParams.RateCheckDown);
   4494 			break;
   4495 	    case RATE_MGMT_RATE_RETRY_POLICY_PARAM:
   4496 			os_error_printf(CU_MSG_INFO2,"RateMngRateRetryPolicy = ");
   4497 
   4498 			for (i=0 ; i< RATE_MNG_MAX_RETRY_POLICY_PARAMS_LEN ; i++)
   4499 			{
   4500 				os_error_printf(CU_MSG_INFO2,"%d ",ReadRateParams.RateRetryPolicy[i]);
   4501 			}
   4502 
   4503 			os_error_printf(CU_MSG_INFO2,"\n");
   4504 
   4505 			break;
   4506 
   4507 	    case RATE_MGMT_ALL_PARAMS:
   4508 		   os_error_printf(CU_MSG_INFO2,"RateMngRateRetryScore = %d \n", ReadRateParams.RateRetryScore);
   4509            os_error_printf(CU_MSG_INFO2,"RateMngPerAdd = %d\n" , ReadRateParams.PerAdd);
   4510            os_error_printf(CU_MSG_INFO2,"RateMngPerTh1 = %d\n" , ReadRateParams.PerTh1);
   4511            os_error_printf(CU_MSG_INFO2,"RateMngPerTh2 = %d\n" , ReadRateParams.PerTh2);
   4512 		   os_error_printf(CU_MSG_INFO2,"RateMngMaxPer = %d\n" , ReadRateParams.MaxPer);
   4513            os_error_printf(CU_MSG_INFO2,"RateMngInverseCuriosityFactor = %d \n" , ReadRateParams.InverseCuriosityFactor);
   4514            os_error_printf(CU_MSG_INFO2,"RateMngTxFailLowTh = %d\n" , ReadRateParams.TxFailLowTh);
   4515 		   os_error_printf(CU_MSG_INFO2,"RateMngTxFailHighTh = %d\n" , ReadRateParams.TxFailHighTh);
   4516            os_error_printf(CU_MSG_INFO2,"RateMngPerAlphaShift = %d\n" , ReadRateParams.PerAlphaShift);
   4517            os_error_printf(CU_MSG_INFO2,"RateMngPerAddShift = %d\n" , ReadRateParams.PerAddShift);
   4518            os_error_printf(CU_MSG_INFO2,"RateMngPerBeta1Shift = %d\n" , ReadRateParams.PerBeta1Shift);
   4519            os_error_printf(CU_MSG_INFO2,"RateMngPerBeta2Shift = %d\n" , ReadRateParams.PerBeta2Shift);
   4520            os_error_printf(CU_MSG_INFO2,"RateMngRateCheckUp = %d\n" , ReadRateParams.RateCheckUp);
   4521 		   os_error_printf(CU_MSG_INFO2,"RateMngRateCheckDown = %d\n" , ReadRateParams.RateCheckDown);
   4522 		   os_error_printf(CU_MSG_INFO2,"RateMngRateRetryPolicy = ");
   4523 
   4524 			for (i=0 ; i< RATE_MNG_MAX_RETRY_POLICY_PARAMS_LEN ; i++)
   4525 			{
   4526 				os_error_printf(CU_MSG_INFO2,"%d ",ReadRateParams.RateRetryPolicy[i]);
   4527 			}
   4528 			os_error_printf(CU_MSG_INFO2,"\n");
   4529 		 break;
   4530 
   4531 		default:
   4532 			os_error_printf(CU_MSG_INFO2,"Error: index is not valid! \n");
   4533 			return;
   4534 	 }
   4535 
   4536 }
   4537 
   4538 
   4539 VOID CuCmd_PrintDriverDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4540 {
   4541     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4542 	U32 size		= 0;
   4543 	TTwdDebug data;
   4544 
   4545 	/* check if nParam is invalid */
   4546 	if (( nParms == 0 ) || ( nParms > 4 ))
   4547 	{
   4548 		os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: Invalid number of Parameters %d\n", nParms);
   4549 		return;
   4550 	}
   4551 
   4552 	/* init */
   4553     os_memset( &data.debug_data.mem_debug.UBuf.buf8, 0, sizeof(data.debug_data.mem_debug.UBuf.buf8) );
   4554 	data.func_id 						= parm[0].value;
   4555 	size								= sizeof(data.func_id);
   4556 
   4557 	os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: FUN_ID: %u\n", data.func_id);
   4558 
   4559 	/* if R reg request - read data */
   4560     if ( nParms == 2 )
   4561 	{
   4562         data.debug_data.opt_param = 4;
   4563 		data.debug_data.opt_param = parm[1].value;
   4564 		size += sizeof(data.debug_data.opt_param);
   4565 	}
   4566     else
   4567 	/* if W reg request - read data */
   4568 	if ( nParms > 2 )
   4569 	{
   4570         data.debug_data.mem_debug.addr 		= 0;
   4571 
   4572         data.debug_data.mem_debug.length 	= 4;
   4573         size += sizeof(data.debug_data.mem_debug.length);
   4574 
   4575         data.debug_data.mem_debug.addr = parm[1].value;
   4576         size += sizeof(data.debug_data.mem_debug.addr);
   4577 
   4578         data.debug_data.mem_debug.UBuf.buf32[0] = parm[2].value;
   4579         size += sizeof(data.debug_data.mem_debug.UBuf.buf32[0]);
   4580 
   4581 		os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: addr: 0x%x\n", data.debug_data.opt_param);
   4582         os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: data: 0x%x\n", data.debug_data.mem_debug.UBuf.buf32[0]);
   4583 	}
   4584 	CuCommon_PrintDriverDebug(pCuCmd->hCuCommon, (PVOID)&data, size);
   4585 }
   4586 
   4587 VOID CuCmd_PrintDriverDebugBuffer(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4588 {
   4589     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4590 
   4591     U32 func_id = ( nParms > 0 ) ? parm[0].value : 0;
   4592     U32 opt_param = ( nParms > 1 ) ? parm[1].value : 0;
   4593 
   4594     os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebugBuffer: FUNC:%u, PARAM:%u\n", func_id, opt_param);
   4595 
   4596     CuCommon_PrintDriverDebugBuffer(pCuCmd->hCuCommon, func_id, opt_param);
   4597 }
   4598 
   4599 /*-------------------*/
   4600 /* Radio Debug Tests */
   4601 /*-------------------*/
   4602 /* Set the RX channel --> Radio Tune */
   4603 VOID CuCmd_RadioDebug_ChannelTune(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4604 {
   4605     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4606     TPowerMgr_PowerMode Mode;
   4607     TTestCmd data;
   4608 
   4609     if ((nParms == 0) || (nParms > 2))
   4610     {
   4611         os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - Band (0-2.4Ghz, 1-5Ghz, 2-4.9Ghz)\n");
   4612         os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - Channel\n");
   4613     }
   4614     else
   4615     {
   4616         if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET,
   4617             &Mode, sizeof(TPowerMgr_PowerMode))) return;
   4618         if(Mode.PowerMode != OS_POWER_MODE_ACTIVE)
   4619         {
   4620             os_error_printf(CU_MSG_INFO2, (PS8)"Radio tune was not performed becouse Default power-mode is not ACTIVE\n");
   4621         }
   4622         else
   4623         {
   4624 			os_memset(&data, 0, sizeof(TTestCmd));
   4625 			data.testCmdId 						= TEST_CMD_CHANNEL_TUNE;
   4626 			data.testCmd_u.Channel.iChannel 	= (U8)parm[1].value;
   4627 			data.testCmd_u.Channel.iBand 		= (U8)parm[0].value;
   4628 
   4629 			if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4630 			{
   4631 				os_error_printf(CU_MSG_INFO2, (PS8)"Channel %d tune failed\n",data.testCmd_u.Channel.iChannel);
   4632 				return;
   4633 			}
   4634             os_error_printf(CU_MSG_INFO2, (PS8)"Channel tune of channel %d was performed OK\n",(U8)data.testCmd_u.Channel.iChannel);
   4635         }
   4636     }
   4637 }
   4638 
   4639 /* Start CW test (TELEC) */
   4640 VOID CuCmd_RadioDebug_StartTxCw(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4641 {
   4642 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4643 	TTestCmd data;
   4644 
   4645 	/* check # of params OK */
   4646     if ((nParms == 0) || (nParms > 2))
   4647     {
   4648 		/* print help */
   4649         os_error_printf(CU_MSG_INFO2, (PS8)"Param 0  - Power (0-25000 1/1000 db)\n");
   4650         os_error_printf(CU_MSG_INFO2, (PS8)"Param 1  - Tone Type (1- Carrier Feed Through, 2- Single Tone)\n");
   4651 
   4652 /*        os_error_printf(CU_MSG_INFO2, (PS8)"Param 2  - Band\n");
   4653         os_error_printf(CU_MSG_INFO2, (PS8)"Param 3  - Channel\n");
   4654         os_error_printf(CU_MSG_INFO2, (PS8)"Param 4  - PPA Step\n");
   4655         os_error_printf(CU_MSG_INFO2, (PS8)"Param 5  - Tone no. Single Tones\n");
   4656         os_error_printf(CU_MSG_INFO2, (PS8)"Param 6  - Tone no. Two Tones\n");
   4657         os_error_printf(CU_MSG_INFO2, (PS8)"Param 7  - Use digital DC\n");
   4658         os_error_printf(CU_MSG_INFO2, (PS8)"Param 8  - Invert\n");
   4659         os_error_printf(CU_MSG_INFO2, (PS8)"Param 9  - Eleven N Span\n");
   4660         os_error_printf(CU_MSG_INFO2, (PS8)"Param 10 - Digital DC\n");
   4661         os_error_printf(CU_MSG_INFO2, (PS8)"Param 11 - Analog DC Fine\n");
   4662         os_error_printf(CU_MSG_INFO2, (PS8)"Param 12 - Analog DC Course\n");*/
   4663     }
   4664     else
   4665     {
   4666 		os_memset(&data, 0, sizeof(TTestCmd));
   4667 		data.testCmdId 										= TEST_CMD_TELEC;
   4668         data.testCmd_u.TxToneParams.iPower 					= (U16)parm[0].value;
   4669         data.testCmd_u.TxToneParams.iToneType 				= (U8)parm[1].value;
   4670 /*		data.testCmd_u.TxToneParams.iPpaStep 				= (U8)parm[4].value;
   4671 		data.testCmd_u.TxToneParams.iToneNumberSingleTones 	= (U8)parm[5].value;
   4672 		data.testCmd_u.TxToneParams.iToneNumberTwoTones 	= (U8)parm[6].value;
   4673 		data.testCmd_u.TxToneParams.iUseDigitalDC 			= (U8)parm[7].value;
   4674 		data.testCmd_u.TxToneParams.iInvert 				= (U8)parm[8].value;
   4675 		data.testCmd_u.TxToneParams.iElevenNSpan 			= (U8)parm[9].value;
   4676 		data.testCmd_u.TxToneParams.iDigitalDC 				= (U8)parm[10].value;
   4677 		data.testCmd_u.TxToneParams.iAnalogDCFine 			= (U8)parm[11].value;
   4678 		data.testCmd_u.TxToneParams.iAnalogDCCoarse 		= (U8)parm[12].value;*/
   4679 
   4680 		if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4681 		{
   4682 			os_error_printf(CU_MSG_INFO2, (PS8)"CW test failed\n");
   4683 			return;
   4684 		}
   4685         os_error_printf(CU_MSG_INFO2, (PS8)"CW test was performed OK\n");
   4686     }
   4687 }
   4688 
   4689 /* Start TX continues test (FCC) */
   4690 VOID CuCmd_RadioDebug_StartContinuousTx(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4691 {
   4692     TMacAddr mac_addr_mask 	= { 0xff,0xff,0xff,0xff,0xff,0xff };
   4693 	CuCmd_t* pCuCmd 		= (CuCmd_t*)hCuCmd;
   4694 	TTestCmd data;
   4695 
   4696     if ((nParms == 0) || (nParms > 15))
   4697     {
   4698 		/* print help */
   4699         os_error_printf(CU_MSG_INFO2, (PS8)"\n");
   4700         os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - Delay\n");
   4701 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - Rate\n");
   4702 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 2  - Size\n");
   4703 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 3  - Amount\n");
   4704 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 4  - Power\n");
   4705 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 5  - Seed\n");
   4706 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 6  - Packet Mode\n");
   4707 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 7  - DCF On/Off\n");
   4708 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 8  - GI\n");
   4709 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 9  - Preamble\n");
   4710 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 10 - Type\n");
   4711 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 11 - Scrambler\n");
   4712 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 12 - Enable CLPC\n");
   4713 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 13 - Sequance no. Mode\n");
   4714         /* future use. for now the oregenal source address are use.
   4715         os_error_printf(CU_MSG_INFO2, (PS8)"Param 14 - Source MAC Address\n");
   4716         */
   4717 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 14 - Destination MAC Address\n");
   4718     }
   4719     else
   4720     {
   4721 		os_memset(&data, 0, sizeof(TTestCmd));
   4722 		data.testCmdId = TEST_CMD_FCC;
   4723 		data.testCmd_u.TxPacketParams.iDelay 			= (U32)parm[0].value;
   4724 		data.testCmd_u.TxPacketParams.iRate 			= (U32)parm[1].value;
   4725 		data.testCmd_u.TxPacketParams.iSize 			= (U16)parm[2].value;
   4726 		data.testCmd_u.TxPacketParams.iAmount 			= (U16)parm[3].value;
   4727 		data.testCmd_u.TxPacketParams.iPower 			= (U16)parm[4].value;
   4728 		data.testCmd_u.TxPacketParams.iSeed 			= (U16)parm[5].value;
   4729 		data.testCmd_u.TxPacketParams.iPacketMode 		= (U8)parm[6].value;
   4730 		data.testCmd_u.TxPacketParams.iDcfOnOff 		= (U8)parm[7].value;
   4731 		data.testCmd_u.TxPacketParams.iGI 				= (U8)parm[8].value;
   4732 		data.testCmd_u.TxPacketParams.iPreamble 		= (U8)parm[9].value;
   4733 		data.testCmd_u.TxPacketParams.iType 			= (U8)parm[10].value;
   4734 		data.testCmd_u.TxPacketParams.iScrambler 		= (U8)parm[11].value;
   4735 		data.testCmd_u.TxPacketParams.iEnableCLPC 		= (U8)parm[12].value;
   4736 		data.testCmd_u.TxPacketParams.iSeqNumMode 		= (U8)parm[13].value;
   4737         /* future use. for now the oregenal source address are use.
   4738         if(!CuCmd_Str2MACAddr((PS8)parm[16].value, (PU8)mac_addr_mask) )
   4739 		{
   4740 			os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx start has failed to read source MAC Address \n");
   4741 			return;
   4742 		}
   4743         */
   4744 		os_memcpy((PVOID)data.testCmd_u.TxPacketParams.iSrcMacAddr,
   4745 				  (PVOID)mac_addr_mask,
   4746 				  sizeof(mac_addr_mask));
   4747 		if(!CuCmd_Str2MACAddr((PS8)parm[14].value, (PU8)mac_addr_mask) )
   4748 		{
   4749 			os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx start has failed to read destination MAC Address \n");
   4750 			return;
   4751 		}
   4752 		os_memcpy((PVOID)data.testCmd_u.TxPacketParams.iDstMacAddr,
   4753 				  (PVOID)mac_addr_mask,
   4754 				  sizeof(mac_addr_mask));
   4755 
   4756         if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4757 		{
   4758 			os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx start has failed\n");
   4759 			return;
   4760 		}
   4761         os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx started OK\n");
   4762    }
   4763 }
   4764 
   4765 /* Stop FCC/TELEC (Radio Debug) */
   4766 VOID CuCmd_RadioDebug_StopTx(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4767 {
   4768     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4769     TTestCmd data;
   4770 
   4771     os_memset(&data, 0, sizeof(TTestCmd));
   4772     data.testCmdId = TEST_CMD_STOP_TX;
   4773 
   4774 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4775 	{
   4776         os_error_printf(CU_MSG_INFO2, (PS8)"Plt Tx Stop has failed\n");
   4777 		return;
   4778 	}
   4779 	os_error_printf(CU_MSG_INFO2, (PS8)"Plt Tx Stop was OK\n");
   4780 }
   4781 
   4782 /* download packet template for transmissions
   4783 	the template shall be set before calling TX Debug */
   4784 VOID CuCmd_RadioDebug_Template(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4785 {
   4786     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4787     TTestCmd data;
   4788 
   4789     if ((nParms == 0) || (nParms > 3))
   4790     {
   4791 		/* print help */
   4792         os_error_printf(CU_MSG_INFO2, (PS8)"\n");
   4793 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 	- Buffer Offset\n");
   4794 		os_error_printf(CU_MSG_INFO2, (PS8)"Param 2 	- Buffer Data\n");
   4795 	}
   4796 	else
   4797 	{
   4798 		os_memset(&data, 0, sizeof(TTestCmd));
   4799 		data.testCmdId 									= TEST_CMD_PLT_TEMPLATE;
   4800 		data.testCmd_u.TxTemplateParams.bufferOffset 	= (U16)parm[0].value;
   4801 		data.testCmd_u.TxTemplateParams.bufferLength	= (U16)os_strlen((PS8)parm[1].value);
   4802 		/* check that length is valid */
   4803 		if( data.testCmd_u.TxTemplateParams.bufferOffset + data.testCmd_u.TxTemplateParams.bufferLength > TX_TEMPLATE_MAX_BUF_LEN )
   4804 		{
   4805 			os_error_printf(CU_MSG_INFO2, (PS8)"Plt Template has failed because of invalid buffer length\n");
   4806 			return;
   4807 		}
   4808 		/* convert the string to hexadeciaml values, and copy it */
   4809 		CuCmd_atox_string ((U8*)parm[1].value,(U8*)data.testCmd_u.TxTemplateParams.buffer);
   4810 
   4811 		if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4812 		{
   4813 			os_error_printf(CU_MSG_INFO2, (PS8)"Plt Template has failed\n");
   4814 			return;
   4815 		}
   4816 		os_error_printf(CU_MSG_INFO2, (PS8)"Plt Template was OK\n");
   4817 	}
   4818 }
   4819 
   4820 
   4821 /* Start RX Statistics */
   4822 VOID CuCmd_RadioDebug_StartRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4823 {
   4824     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4825     TTestCmd data;
   4826 
   4827     os_memset(&data, 0, sizeof(TTestCmd));
   4828     data.testCmdId = TEST_CMD_RX_STAT_START;
   4829 
   4830 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4831     {
   4832 		os_error_printf(CU_MSG_INFO2, (PS8)"Start RX Statistics has failed\n");
   4833 		return;
   4834     }
   4835 	os_error_printf(CU_MSG_INFO2, (PS8)"Start RX Statistics OK\n");
   4836 }
   4837 
   4838 /* Stop RX Statistics */
   4839 VOID CuCmd_RadioDebug_StopRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4840 {
   4841     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4842     TTestCmd data;
   4843 
   4844     os_memset(&data, 0, sizeof(TTestCmd));
   4845     data.testCmdId = TEST_CMD_RX_STAT_STOP;
   4846 
   4847 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4848     {
   4849 		os_error_printf(CU_MSG_INFO2, (PS8)"Stop RX Statistics has failed\n");
   4850 		return;
   4851     }
   4852 	os_error_printf(CU_MSG_INFO2, (PS8)"Stop RX Statistics OK\n");
   4853 }
   4854 
   4855 /* Reset RX Statistics */
   4856 VOID CuCmd_RadioDebug_ResetRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4857 {
   4858     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4859     TTestCmd data;
   4860 
   4861     os_memset(&data, 0, sizeof(TTestCmd));
   4862     data.testCmdId = TEST_CMD_RX_STAT_RESET;
   4863 
   4864 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4865     {
   4866 		os_error_printf(CU_MSG_INFO2, (PS8)"Reset RX Statistics has failed\n");
   4867 		return;
   4868     }
   4869 	os_error_printf(CU_MSG_INFO2, (PS8)"Reset RX Statistics OK\n");
   4870 }
   4871 
   4872 
   4873 /* Get HDK Version*/
   4874 VOID CuCmd_RadioDebug_GetHDKVersion(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4875 {
   4876 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4877 	TTestCmd data;
   4878 
   4879 	os_memset(&data, 0, sizeof(TTestCmd));
   4880 
   4881 	data.testCmdId = TEST_CMD_GET_FW_VERSIONS;
   4882 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4883 	{
   4884 		os_error_printf(CU_MSG_INFO2, (PS8)"Get FW version function has failed\n");
   4885 		return;
   4886 	}
   4887 	os_error_printf(CU_MSG_INFO2, (PS8)"ProductName:                       %d\n", data.testCmd_u.fwVersions.hdkVersion.ProductName);
   4888 	os_error_printf(CU_MSG_INFO2, (PS8)"PgNumber:                          %d\n", data.testCmd_u.fwVersions.hdkVersion.PgNumber);
   4889 	os_error_printf(CU_MSG_INFO2, (PS8)"SoftwareVersionLevel:              %d\n", data.testCmd_u.fwVersions.hdkVersion.SoftwareVersionLevel);
   4890 	os_error_printf(CU_MSG_INFO2, (PS8)"radioModuleType:                   %d\n", data.testCmd_u.fwVersions.hdkVersion.radioModuleType);
   4891 	os_error_printf(CU_MSG_INFO2, (PS8)"SoftwareVersionDelivery:           %d\n", data.testCmd_u.fwVersions.hdkVersion.SoftwareVersionDelivery);
   4892 	os_error_printf(CU_MSG_INFO2, (PS8)"numberOfReferenceDesignsSupported: %d\n", data.testCmd_u.fwVersions.hdkVersion.numberOfReferenceDesignsSupported);
   4893 #ifdef FIX_HDK_VERSION_API /* HDK version struct should be changed aligned and without pointer */
   4894 	os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->referenceDesignId: %d\n",    data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->referenceDesignId);
   4895 	os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->nvsMajorVersion: %d\n",      data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->nvsMajorVersion);
   4896 	os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->nvsMinorVersion: %d\n",      data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->nvsMinorVersion);
   4897 	os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->nvsMinorMinorVersion: %d\n", data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->nvsMinorMinorVersion);
   4898 #endif
   4899 }
   4900 
   4901 /* Get RX Statistics */
   4902 VOID CuCmd_RadioDebug_GetRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   4903 {
   4904 #if 0 /*Temp: currently not supported*/
   4905 	U32 i 			= 0;
   4906 #endif
   4907 
   4908     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4909     TTestCmd data;
   4910 
   4911     os_memset(&data, 0, sizeof(TTestCmd));
   4912     data.testCmdId = TEST_CMD_RX_STAT_GET;
   4913 
   4914 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   4915     {
   4916 		os_error_printf(CU_MSG_INFO2, (PS8)"Get RX Statistics has failed\n");
   4917 		return;
   4918     }
   4919 	/* print Statistics Got */
   4920 	os_error_printf(CU_MSG_INFO2, (PS8)"\n");
   4921 	os_error_printf(CU_MSG_INFO2, (PS8)"Received Valid Packet no.: %d(0x%x)\n", data.testCmd_u.Statistics.oRxPathStatistics.ReceivedValidPacketsNumber,data.testCmd_u.Statistics.oRxPathStatistics.ReceivedValidPacketsNumber);
   4922 	os_error_printf(CU_MSG_INFO2, (PS8)"Received FCS Error Packet no.: %d(0x%x)\n", data.testCmd_u.Statistics.oRxPathStatistics.ReceivedFcsErrorPacketsNumber,data.testCmd_u.Statistics.oRxPathStatistics.ReceivedFcsErrorPacketsNumber);
   4923 	os_error_printf(CU_MSG_INFO2, (PS8)"Received Address mismatched packet: %d(0x%x)\n", data.testCmd_u.Statistics.oRxPathStatistics.ReceivedPlcpErrorPacketsNumber,data.testCmd_u.Statistics.oRxPathStatistics.ReceivedPlcpErrorPacketsNumber);
   4924 	os_error_printf(CU_MSG_INFO2, (PS8)"Sequance Nomber Missing Count: %d(0x%x)\n", data.testCmd_u.Statistics.oRxPathStatistics.SeqNumMissCount,data.testCmd_u.Statistics.oRxPathStatistics.SeqNumMissCount);
   4925 	/* The RSSI and SNR are in octal units, the value divided by 8 for the print */
   4926 	os_error_printf(CU_MSG_INFO2, (PS8)"Average SNR: %d(0x%x)\n", data.testCmd_u.Statistics.oRxPathStatistics.AverageSnr/8,data.testCmd_u.Statistics.oRxPathStatistics.AverageSnr/8);
   4927 	os_error_printf(CU_MSG_INFO2, (PS8)"Average RSSI: %d(0x%x)\n", (data.testCmd_u.Statistics.oRxPathStatistics.AverageRssi)/8,(data.testCmd_u.Statistics.oRxPathStatistics.AverageRssi)/8);
   4928 	os_error_printf(CU_MSG_INFO2, (PS8)"Base Packet ID: %d(0x%x)\n", data.testCmd_u.Statistics.oBasePacketId,data.testCmd_u.Statistics.oBasePacketId);
   4929 	os_error_printf(CU_MSG_INFO2, (PS8)"Number of Packets: %d(0x%x)\n", data.testCmd_u.Statistics.ioNumberOfPackets,data.testCmd_u.Statistics.ioNumberOfPackets);
   4930 	os_error_printf(CU_MSG_INFO2, (PS8)"Number of Missed Packets: %d(0x%x)\n", data.testCmd_u.Statistics.oNumberOfMissedPackets,data.testCmd_u.Statistics.oNumberOfMissedPackets);
   4931 #if 0/*Temp: currently not supported*/
   4932 	for ( i = 0 ; i < RX_STAT_PACKETS_PER_MESSAGE ; i++ )
   4933 	{
   4934 		os_error_printf(CU_MSG_INFO2, (PS8)"RX Packet %d Statistics\n",i);
   4935 		os_error_printf(CU_MSG_INFO2, (PS8)"Length: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].Length,data.testCmd_u.Statistics.RxPacketStatistics[i].Length);
   4936 		os_error_printf(CU_MSG_INFO2, (PS8)"EVM: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].EVM,data.testCmd_u.Statistics.RxPacketStatistics[i].EVM);
   4937 		os_error_printf(CU_MSG_INFO2, (PS8)"RSSI: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].RSSI,data.testCmd_u.Statistics.RxPacketStatistics[i].RSSI);
   4938 		os_error_printf(CU_MSG_INFO2, (PS8)"Frequency Delta: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].FrequencyDelta,data.testCmd_u.Statistics.RxPacketStatistics[i].FrequencyDelta);
   4939 		os_error_printf(CU_MSG_INFO2, (PS8)"Flags: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].Flags,data.testCmd_u.Statistics.RxPacketStatistics[i].Flags);
   4940 		os_error_printf(CU_MSG_INFO2, (PS8)"Type: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].Type,data.testCmd_u.Statistics.RxPacketStatistics[i].Type);
   4941 		os_error_printf(CU_MSG_INFO2, (PS8)"Rate: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].Rate,data.testCmd_u.Statistics.RxPacketStatistics[i].Rate);
   4942 		os_error_printf(CU_MSG_INFO2, (PS8)"Noise: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].Noise,data.testCmd_u.Statistics.RxPacketStatistics[i].Noise);
   4943 		os_error_printf(CU_MSG_INFO2, (PS8)"AGC Gain: %d(0x%x)\n", data.testCmd_u.Statistics.RxPacketStatistics[i].AgcGain,data.testCmd_u.Statistics.RxPacketStatistics[i].AgcGain);
   4944 	}
   4945 #endif
   4946 }
   4947 
   4948 
   4949 /*-----------*/
   4950 /* BIP Tests */
   4951 /*-----------*/
   4952 
   4953 
   4954 void nvsFillMACAddress(THandle hCuCmd, FILE *nvsBinFile)
   4955 {
   4956 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   4957 	TMacAddr Mac;
   4958 	U8	lengthToSet;
   4959 	U8	addressHigher;
   4960 	U8	addressLower;
   4961 	U8	valueToSet=0;
   4962 
   4963 	lengthToSet = 0x1;
   4964 
   4965 
   4966 	os_error_printf(CU_MSG_INFO2, (PS8)"Entering FillMACAddressToNVS\n");
   4967 	/* param 0 in nvs*/
   4968 	os_fwrite(&lengthToSet, sizeof(U8), 1, nvsBinFile);
   4969 
   4970 	/* register for MAC Address*/
   4971 	addressHigher	= 0x6D;
   4972 	addressLower	= 0x54;
   4973 
   4974 	/* param 1 in nvs*/
   4975 	os_fwrite(&addressHigher, sizeof(U8), 1, nvsBinFile);
   4976 	/* param 2 in nvs*/
   4977 	os_fwrite(&addressLower, sizeof(U8), 1, nvsBinFile);
   4978 
   4979 
   4980    /*	read mac address */
   4981 	if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, CTRL_DATA_MAC_ADDRESS, Mac, sizeof(TMacAddr)))
   4982 	{
   4983 		os_error_printf(CU_MSG_INFO2, (PS8)"Unable  to get Mac address, aborting\n");
   4984 		return;
   4985 	}
   4986 	os_error_printf(CU_MSG_INFO2, (PS8)"Mac[0]=%02x\n", Mac[0]);
   4987 	os_error_printf(CU_MSG_INFO2, (PS8)"Mac[1]=%02x\n", Mac[1]);
   4988 	os_error_printf(CU_MSG_INFO2, (PS8)"Mac[2]=%02x\n", Mac[2]);
   4989 	os_error_printf(CU_MSG_INFO2, (PS8)"Mac[3]=%02x\n", Mac[3]);
   4990 	os_error_printf(CU_MSG_INFO2, (PS8)"Mac[4]=%02x\n", Mac[4]);
   4991 	os_error_printf(CU_MSG_INFO2, (PS8)"Mac[5]=%02x\n", Mac[5]);
   4992 
   4993 	/* write the lower MAC address starting from the LSB
   4994 	   params 3-6 in NVS*/
   4995 	os_fwrite(&Mac[5], sizeof(U8), 1, nvsBinFile);
   4996 	os_fwrite(&Mac[4], sizeof(U8), 1, nvsBinFile);
   4997 	os_fwrite(&Mac[3], sizeof(U8), 1, nvsBinFile);
   4998 	os_fwrite(&Mac[2], sizeof(U8), 1, nvsBinFile);
   4999 
   5000     /* param 7 in NVS*/
   5001 	os_fwrite(&lengthToSet, sizeof(U8), 1, nvsBinFile);
   5002 
   5003 	addressHigher	= 0x71;
   5004 	addressLower	= 0x54;
   5005 
   5006 	/* params 8-9 in NVS*/
   5007 	os_fwrite(&addressHigher, sizeof(U8), 1, nvsBinFile);
   5008 	os_fwrite(&addressLower, sizeof(U8), 1, nvsBinFile);
   5009 
   5010 
   5011     /* Write the higher MAC address starting from the LSB
   5012 	   params 10-13 in NVS*/
   5013 	os_fwrite(&Mac[1], sizeof(U8), 1, nvsBinFile);
   5014 	os_fwrite(&Mac[0], sizeof(U8), 1, nvsBinFile);
   5015 
   5016     os_fwrite(&valueToSet, sizeof(U8), 1, nvsBinFile);
   5017 	os_fwrite(&valueToSet, sizeof(U8), 1, nvsBinFile);
   5018 
   5019     os_error_printf(CU_MSG_INFO2, (PS8)"exiting FillMACAddressToNVS\n");
   5020 }
   5021 
   5022 TI_BOOL nvsReadFile(TI_UINT8 *pReadBuffer, TI_UINT16 *length, char* nvsFilePath)
   5023 {
   5024 	FILE      *nvsBinFile = NULL;
   5025 	TI_UINT8  nvsData;
   5026 	TI_INT8   nvsFileValid = TRUE;
   5027 	TI_UINT32 index =0;
   5028 
   5029 	if (NULL == (nvsBinFile = os_fopen (nvsFilePath, OS_FOPEN_READ_BINARY)))
   5030     {
   5031        nvsFileValid = FALSE;
   5032 	   return TI_FALSE;
   5033     }
   5034 
   5035 	do
   5036 	{
   5037 		os_fread(&nvsData, sizeof(TI_UINT8), 1, nvsBinFile);
   5038 		pReadBuffer[index++] = nvsData;
   5039 	} while((!feof(nvsBinFile)) && (index < NVS_TOTAL_LENGTH)) ;
   5040 
   5041 	*length = index;
   5042 	os_fclose(nvsBinFile);
   5043 
   5044 	return TI_TRUE;
   5045 }
   5046 
   5047 
   5048 VOID nvsParsePreviosOne(const uint8 *nvsBuffer, TNvsStruct *nvsTypeTLV, uint32 *nvsVersion)
   5049 {
   5050 #define BUFFER_INDEX	bufferIndex + START_PARAM_INDEX + infoModeIndex
   5051 
   5052 	uint16		bufferIndex;
   5053 	uint8		tlvType;
   5054 	uint16		tlvLength;
   5055 	uint16		infoModeIndex;
   5056 	NVSTypeInfo	nvsTypeInfo;
   5057 	uint8		nvsVersionOctetIndex;
   5058 	uint8		shift;
   5059 
   5060 	for (bufferIndex = 0; bufferIndex < NVS_TOTAL_LENGTH;)
   5061 	{
   5062 		tlvType = nvsBuffer[bufferIndex];
   5063 
   5064 		/* fill the correct mode to fill the NVS struct buffer */
   5065 		/* if the tlvType is the last type break from the loop */
   5066 		switch(tlvType)
   5067 		{
   5068 			case eNVS_RADIO_TX_PARAMETERS:
   5069 				nvsTypeInfo = eNVS_RADIO_TX_TYPE_PARAMETERS_INFO;
   5070 				break;
   5071 
   5072 			case eNVS_RADIO_RX_PARAMETERS:
   5073 				nvsTypeInfo = eNVS_RADIO_RX_TYPE_PARAMETERS_INFO;
   5074 				break;
   5075 
   5076 			case eNVS_VERSION:
   5077 				for (*nvsVersion = 0, nvsVersionOctetIndex = 0; nvsVersionOctetIndex < NVS_VERSION_PARAMETER_LENGTH; nvsVersionOctetIndex++)
   5078 				{
   5079 					shift = 8 * (NVS_VERSION_PARAMETER_LENGTH - 1 - nvsVersionOctetIndex);
   5080 					*nvsVersion += ((nvsBuffer[bufferIndex + START_PARAM_INDEX + nvsVersionOctetIndex]) << shift);
   5081 				}
   5082 				break;
   5083 
   5084 			case eTLV_LAST:
   5085 			default:
   5086 				return;
   5087 		}
   5088 
   5089 		tlvLength = (nvsBuffer[bufferIndex + START_LENGTH_INDEX  + 1] << 8) + nvsBuffer[bufferIndex + START_LENGTH_INDEX];
   5090 
   5091 		/* if TLV type is not NVS version fill the NVS structure according to the mode TX/RX */
   5092 		if ((eNVS_RADIO_TX_PARAMETERS == tlvType) || (eNVS_RADIO_RX_PARAMETERS == tlvType))
   5093 		{
   5094 			nvsTypeTLV[nvsTypeInfo].Type = tlvType;
   5095 			nvsTypeTLV[nvsTypeInfo].Length = tlvLength;
   5096 
   5097 			for (infoModeIndex = 0; (infoModeIndex < tlvLength) && (BUFFER_INDEX < NVS_TOTAL_LENGTH); infoModeIndex++)
   5098 			{
   5099 				nvsTypeTLV[nvsTypeInfo].Buffer[infoModeIndex] = nvsBuffer[BUFFER_INDEX];
   5100 			}
   5101 
   5102 		}
   5103 
   5104 		/* increment to the next TLV */
   5105 		bufferIndex += START_PARAM_INDEX + tlvLength;
   5106 	}
   5107 }
   5108 
   5109 
   5110 VOID nvsFillOldRxParams(FILE *nvsBinFile, const TI_UINT8 *buffer, const uint16 rxLength)
   5111 {
   5112 	TI_UINT16 	index;
   5113 	TI_UINT8	rxTypeValue;
   5114 	TI_UINT8	valueToSet;
   5115 
   5116 	/* RX BiP type */
   5117 	rxTypeValue = eNVS_RADIO_RX_PARAMETERS;
   5118 	fwrite(&rxTypeValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5119 
   5120 	/* RX BIP Length */
   5121 	fwrite(&rxLength, sizeof(TI_UINT16), 1, nvsBinFile);
   5122 
   5123 	for (index = 0; index < rxLength; index++)
   5124 	{
   5125 		valueToSet = buffer[index];
   5126 		fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5127 	}
   5128 }
   5129 
   5130 VOID nvsFillTXParams(FILE *nvsBinFile, TI_UINT8	*nvsPtr, TI_UINT16 txParamLength)
   5131 {
   5132 	TI_UINT8			txParamValue;
   5133 	TI_UINT8			valueToSet;
   5134 	TI_UINT16			index;
   5135 
   5136 	/* TX BiP type */
   5137 	txParamValue = eNVS_RADIO_TX_PARAMETERS;
   5138 	os_fwrite(&txParamValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5139 
   5140 	/* TX Bip Length */
   5141 	os_fwrite(&txParamLength, sizeof(TI_UINT16), 1, nvsBinFile);
   5142 
   5143 	for (index = 0; index < txParamLength; index++)
   5144 	{
   5145 		valueToSet = nvsPtr[index];
   5146 		os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5147 	}
   5148 }
   5149 
   5150 VOID nvsFillDefaultRXParams(FILE *nvsBinFile)
   5151 {
   5152 	TI_UINT8	typeValue = eNVS_RADIO_RX_PARAMETERS;
   5153 	TI_UINT16	lengthValue = NVS_RX_PARAM_LENGTH;
   5154 	TI_UINT8	valueToSet = DEFAULT_EFUSE_VALUE;
   5155 	TI_UINT8	rxParamIndex;
   5156 
   5157 	/* RX type */
   5158 	os_fwrite(&typeValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5159 
   5160 	/* RX length */
   5161 	os_fwrite(&lengthValue, sizeof(TI_UINT16), 1, nvsBinFile);
   5162 
   5163 	for (rxParamIndex = 0; rxParamIndex < lengthValue; rxParamIndex++)
   5164 	{
   5165 		os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5166 	}
   5167 }
   5168 
   5169 
   5170 void nvsFillOldTXParams(FILE *nvsBinFile, const TI_UINT8	*buffer, const uint16	txParamLength)
   5171 {
   5172 	TI_UINT16	index;
   5173 	TI_UINT8	rxTypeValue;
   5174 	TI_UINT8	valueToSet;
   5175 	TI_UINT16	tlvLength;
   5176 
   5177 	/* TX BiP type */
   5178 	rxTypeValue = eNVS_RADIO_TX_PARAMETERS;
   5179 	os_fwrite(&rxTypeValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5180 
   5181 	/* TX BIP Length */
   5182 	tlvLength = txParamLength;
   5183 	os_fwrite(&tlvLength, sizeof(TI_UINT16), 1, nvsBinFile);
   5184 
   5185 	for (index = 0; index < txParamLength; index++)
   5186 	{
   5187 		valueToSet = buffer[index];
   5188 		os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5189 	}
   5190 }
   5191 
   5192 
   5193 VOID nvsFillDefaultTXParams(FILE *nvsBinFile, const uint16	txParamLength)
   5194 {
   5195 	TI_UINT32	index;
   5196 	TI_UINT32	lengthOfP2Gtable = NVS_TX_P2G_TABLE_LENGTH;
   5197 	TI_UINT8	p2GValue = 0;
   5198 	TI_UINT32	lengthOfPPASTepTable = NVS_TX_PPA_STEPS_TABLE_LENGTH;
   5199 	TI_UINT8	ppaStesValue = 0;
   5200 	TI_UINT32	lengthOfPDBufferTable = NVS_TX_PD_TABLE_LENGTH_NVS_V2;
   5201 	TI_UINT8	pdStesValue = 0;
   5202 	TI_UINT8	typeValue = eNVS_RADIO_TX_PARAMETERS;
   5203 	TI_UINT16	lengthValue = txParamLength;
   5204 	TI_UINT8	perChannelGainOffsetValue = 0;
   5205 	TI_UINT16	lengthOfGainOffsetTable = NUMBER_OF_RADIO_CHANNEL_INDEXS_E;
   5206 
   5207 	/* TX type */
   5208 	os_fwrite(&typeValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5209 
   5210 	/* TX length */
   5211 	os_fwrite(&lengthValue, sizeof(TI_UINT16), 1, nvsBinFile);
   5212 
   5213 	/* P2G table */
   5214 	for (index = 0; index < lengthOfP2Gtable; index++)
   5215 	{
   5216 		os_fwrite(&p2GValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5217 	}
   5218 
   5219 	/* PPA steps table */
   5220 	for (index = 0; index < lengthOfPPASTepTable; index++)
   5221 	{
   5222 		os_fwrite(&ppaStesValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5223 	}
   5224 
   5225 	/* Power Detector */
   5226 	for (index = 0; index < lengthOfPDBufferTable; index++)
   5227 	{
   5228 		os_fwrite(&pdStesValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5229 	}
   5230 
   5231 	/* Per Channel Gain Offset */
   5232 	for (index = 0; index < lengthOfGainOffsetTable; index++)
   5233 	{
   5234 		os_fwrite(&perChannelGainOffsetValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5235 	}
   5236 }
   5237 
   5238 void nvsFillRXParams(FILE *nvsBinFile, uint8	*nvsPtr, uint16	rxLength)
   5239 {
   5240 	TI_UINT8	rxTypeValue;
   5241 	TI_UINT8	valueToSet;
   5242 	TI_UINT16	index;
   5243 
   5244 	/* RX BiP type */
   5245 	rxTypeValue = eNVS_RADIO_RX_PARAMETERS;
   5246 	os_fwrite(&rxTypeValue, sizeof(TI_UINT8), 1, nvsBinFile);
   5247 
   5248 	/* RX Bip Length */
   5249 	os_fwrite(&rxLength, sizeof(TI_UINT16), 1, nvsBinFile);
   5250 
   5251 	for (index = 0; index < rxLength; index++)
   5252 	{
   5253 		valueToSet = nvsPtr[index];
   5254 		os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5255 	}
   5256 }
   5257 
   5258 
   5259 VOID  nvsFillVersion(FILE *nvsBinFile, TI_UINT32 version)
   5260 {
   5261 	char			versionBuffer[NVS_VERSION_PARAMETER_LENGTH];
   5262 	TI_UINT8		shift8;
   5263 	TI_UINT8		valueToSet;
   5264 	TI_UINT32		comparison;
   5265 	TI_INT16		index;
   5266 	TI_UINT16		lengthToSet;
   5267 
   5268 	/* version type */
   5269 	valueToSet = eNVS_VERSION;
   5270 	os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5271 
   5272 	/* version length */
   5273 	lengthToSet = NVS_VERSION_PARAMETER_LENGTH;
   5274 	os_fwrite(&lengthToSet, sizeof(TI_UINT16), 1, nvsBinFile);
   5275 
   5276 	for (shift8 = 0, comparison = 0xff, index = NVS_VERSION_PARAMETER_LENGTH - 1;index >= 0; index--)
   5277 	{
   5278 		valueToSet = (version & comparison) >> shift8;
   5279 		versionBuffer[index] = valueToSet;
   5280 
   5281 		comparison <<= 8;
   5282 		shift8 += 8;
   5283 	}
   5284 
   5285 	for (index = 0; index < NVS_VERSION_PARAMETER_LENGTH; index++)
   5286 	{
   5287 		os_fwrite(&versionBuffer[index], sizeof(TI_UINT8), 1, nvsBinFile);
   5288 	}
   5289 }
   5290 
   5291 
   5292 VOID nvsWriteEndNVS(FILE *nvsBinFile)
   5293 {
   5294 	TI_UINT8	valueToSet;
   5295 	TI_UINT16	lengthToSet;
   5296 
   5297 	/* version type */
   5298 	valueToSet = eTLV_LAST;
   5299 	os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5300 
   5301 	valueToSet = eTLV_LAST;
   5302 	os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5303 
   5304 	/* version length */
   5305 	lengthToSet = 0;
   5306 	os_fwrite(&lengthToSet, sizeof(TI_UINT16), 1, nvsBinFile);
   5307 }
   5308 
   5309 VOID nvsUpdateFile(THandle hCuCmd, TNvsStruct nvsStruct, TI_UINT8 version,  S8 updatedProtocol)
   5310 {
   5311 #ifdef _WINDOWS
   5312     PS8 nvsFilePath = (PS8)"/windows/nvs_map.bin";
   5313 #else
   5314     PS8 nvsFilePath = (PS8)"./nvs_map.bin";
   5315 #endif /*_WINDOWS*/
   5316 	TI_UINT8		currentNVSbuffer[1500];
   5317 	TI_UINT16		lengthOfCurrentNVSBufer;
   5318 	TI_BOOL     	prevNVSIsValid;
   5319 	TNvsStruct		oldNVSParam[eNUMBER_RADIO_TYPE_PARAMETERS_INFO];
   5320     FILE			*nvsBinFile;
   5321 	TI_UINT8    	index;
   5322 	TI_UINT8		valueToSet = 0;
   5323 	TI_UINT16		nvsTXParamLength = NVS_TX_PARAM_LENGTH_NVS_V2;
   5324 	TI_UINT16		oldNVSTXParamLength;
   5325 	TI_UINT32		oldNVSVersion;
   5326 	TI_UINT32       currentNVSVersion = NVS_VERSION_2;
   5327 
   5328 	/* read previous NVS if exists */
   5329 	prevNVSIsValid = nvsReadFile(currentNVSbuffer, &lengthOfCurrentNVSBufer, nvsFilePath);
   5330 
   5331 	if (prevNVSIsValid)
   5332 	{
   5333 		/* fill the TLV structure for the mode TX/RX */
   5334 		os_memset(oldNVSParam, 0, eNUMBER_RADIO_TYPE_PARAMETERS_INFO * sizeof(TNvsStruct));
   5335 		nvsParsePreviosOne(&currentNVSbuffer[NVS_PRE_PARAMETERS_LENGTH], oldNVSParam, &oldNVSVersion);
   5336 
   5337 		if (currentNVSVersion == oldNVSVersion)
   5338 		{
   5339 			oldNVSTXParamLength = NVS_TX_PARAM_LENGTH_NVS_V2;
   5340 
   5341 			/* if read all the parameter (needed) from the previous NVS */
   5342 			if ((oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Type != eNVS_RADIO_TX_PARAMETERS)	||
   5343 				(oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Length != nvsTXParamLength)		||
   5344 				(oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Type != eNVS_RADIO_RX_PARAMETERS)	||
   5345 				(oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Length != NVS_RX_PARAM_LENGTH))
   5346 			{
   5347 				/* the parameters are wrong */
   5348 				prevNVSIsValid = TI_FALSE;
   5349 			}
   5350 			else
   5351 			{
   5352 				/* the parameters are right */
   5353 				prevNVSIsValid = TI_TRUE;
   5354 			}
   5355 		}
   5356 		else
   5357 		{
   5358 			/* there isn't NVS */
   5359 			prevNVSIsValid = TI_FALSE;
   5360 		}
   5361 	}
   5362 
   5363 	nvsBinFile = os_fopen(nvsFilePath, OS_FOPEN_WRITE_BINARY);
   5364 
   5365 	if (NULL == nvsBinFile)
   5366 	{
   5367 		os_error_printf(CU_MSG_ERROR, (PS8)"\n Could not create FILE!!! !!!! \n");
   5368 	}
   5369 
   5370 	/* fill MAC Address */
   5371 	nvsFillMACAddress(hCuCmd, nvsBinFile);
   5372 
   5373 	/* fill end burst transaction zeros */
   5374 	for (index = 0; index < NVS_END_BURST_TRANSACTION_LENGTH; index++)
   5375 	{
   5376 		os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5377 	}
   5378 
   5379 	/* fill zeros to Align TLV start address */
   5380 	for (index = 0; index < NVS_ALING_TLV_START_ADDRESS_LENGTH; index++)
   5381 	{
   5382 		os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile);
   5383 	}
   5384 
   5385 	/* Getting from TX BiP Command */
   5386 	if(NVS_FILE_TX_PARAMETERS_UPDATE == updatedProtocol)
   5387 	{
   5388 		// Fill new TX BiP values
   5389 		nvsFillTXParams(nvsBinFile, nvsStruct.Buffer, nvsStruct.Length);
   5390 
   5391 		if (prevNVSIsValid)
   5392 		{
   5393 			/* set Parameters of RX from the previous file */
   5394 			nvsFillOldRxParams(nvsBinFile, oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Buffer,
   5395 							   oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Length);
   5396 		}
   5397 		else
   5398 		{
   5399 			nvsFillDefaultRXParams(nvsBinFile);
   5400 		}
   5401 	}
   5402 	/* Getting from RX BiP Command */
   5403 	else if (NVS_FILE_RX_PARAMETERS_UPDATE == updatedProtocol)
   5404 	{
   5405 		if (prevNVSIsValid)
   5406 		{
   5407 			// set Parameters of TX from the previous file
   5408 			nvsFillOldTXParams(nvsBinFile, oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Buffer,
   5409 									oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Length);
   5410 		}
   5411 		else
   5412 		{
   5413 			nvsFillDefaultTXParams(nvsBinFile, nvsTXParamLength);
   5414 		}
   5415 
   5416 		/* Fill new RX BiP values */
   5417 		nvsFillRXParams(nvsBinFile, nvsStruct.Buffer, nvsStruct.Length);
   5418 
   5419 	}
   5420 	else  /* NVS_FILE_WRONG_UPDATE == updatedProtocol */
   5421 	{
   5422 		if (prevNVSIsValid)
   5423 		{
   5424 			/* set Parameters of TX from the previous file */
   5425 			nvsFillOldTXParams(nvsBinFile,
   5426 									oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Buffer,
   5427 				                    oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Length);
   5428 
   5429 			/* set Parameters of RX from the previous file  */
   5430 			nvsFillOldRxParams(nvsBinFile,
   5431 									oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Buffer,
   5432 				                    oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Length);
   5433 		}
   5434 		else
   5435 		{
   5436 			/* set default TX param */
   5437 			nvsFillDefaultTXParams(nvsBinFile,nvsTXParamLength);
   5438 
   5439 			/* set default RX param */
   5440 			nvsFillDefaultRXParams(nvsBinFile);
   5441 		}
   5442 	}
   5443 
   5444 	/* Fill the NVS version to the NVS */
   5445 	nvsFillVersion(nvsBinFile, version);
   5446 
   5447 	/* End of NVS */
   5448 	nvsWriteEndNVS(nvsBinFile);
   5449 
   5450 	/* close the file */
   5451 	os_fclose(nvsBinFile);
   5452 }
   5453 
   5454 VOID CuCmd_BIP_BufferCalReferencePoint(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5455 {
   5456 #define NUM_OF_PARAMETERS_REF_POINT 3
   5457 
   5458 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5459 	TTestCmd data;
   5460 
   5461 	if(nParms != NUM_OF_PARAMETERS_REF_POINT)
   5462 	{
   5463 		os_error_printf(CU_MSG_INFO2, (PS8)"Missing Param1: iReferencePointDetectorValue\n");
   5464 		os_error_printf(CU_MSG_INFO2, (PS8)"Missing Param2: iReferencePointPower\n");
   5465 		os_error_printf(CU_MSG_INFO2, (PS8)"Missing Param3: isubBand\n");
   5466 		return;
   5467 	}
   5468 	else
   5469 	{
   5470 		os_memset(&data, 0, sizeof(TTestCmd));
   5471 		data.testCmdId = TEST_CMD_UPDATE_PD_REFERENCE_POINT;
   5472 /*		data.testCmd_u.PdBufferCalReferencePoint.iReferencePointDetectorValue = 189;
   5473 		data.testCmd_u.PdBufferCalReferencePoint.iReferencePointPower = 12;
   5474 		data.testCmd_u.PdBufferCalReferencePoint.isubBand = 0; 1- BG 2-*/
   5475 
   5476 		data.testCmd_u.PdBufferCalReferencePoint.iReferencePointDetectorValue = parm[0].value;
   5477 		data.testCmd_u.PdBufferCalReferencePoint.iReferencePointPower = parm[1].value;
   5478 		data.testCmd_u.PdBufferCalReferencePoint.isubBand = (U8)parm[2].value;
   5479 
   5480 		if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   5481 		{
   5482 			os_error_printf(CU_MSG_INFO2, (PS8)"BufferCalReferencePoint has failed\n");
   5483 			return;
   5484 		}
   5485 
   5486 		os_error_printf(CU_MSG_INFO2, (PS8)"BufferCalReferencePoint was configured succesfully\n");
   5487 	}
   5488 	return;
   5489 }
   5490 
   5491 
   5492 /* P2G Calibration */
   5493 VOID CuCmd_BIP_StartBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5494 {
   5495 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5496     TTestCmd data;
   5497     U32 i;
   5498 
   5499 	os_memset(&data, 0, sizeof(TTestCmd));
   5500 
   5501 	data.testCmdId = TEST_CMD_P2G_CAL;
   5502 
   5503     data.testCmd_u.P2GCal.iSubBandMask = 0;
   5504     for (i = 0; i < 8; i++)
   5505     {
   5506         data.testCmd_u.P2GCal.iSubBandMask |= (U8)parm[i].value << i;
   5507     }
   5508 
   5509 	if (data.testCmd_u.P2GCal.iSubBandMask == 0)
   5510 	{
   5511 		os_error_printf(CU_MSG_INFO2, (PS8)"At least one sub-band should be enabled\n");
   5512 		return;
   5513 	}
   5514 
   5515 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   5516 	{
   5517 		os_error_printf(CU_MSG_INFO2, (PS8)"Tx calibration start has failed\n");
   5518 		return;
   5519 	}
   5520 
   5521 	if (TI_OK != data.testCmd_u.P2GCal.oRadioStatus) {
   5522 		os_error_printf(CU_MSG_INFO2, (PS8)"Tx calibration returned status: %d\n", data.testCmd_u.P2GCal.oRadioStatus);
   5523 		return;
   5524 	}
   5525 
   5526 	nvsUpdateFile(hCuCmd,data.testCmd_u.P2GCal.oNvsStruct , (TI_UINT8)data.testCmd_u.P2GCal.oNVSVersion, NVS_FILE_TX_PARAMETERS_UPDATE);
   5527 
   5528 }
   5529 
   5530 VOID CuCmd_BIP_EnterRxBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5531 {
   5532 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5533     TTestCmd data;
   5534 
   5535 	os_memset(&data, 0, sizeof(TTestCmd));
   5536 
   5537 	data.testCmdId = TEST_CMD_RX_PLT_ENTER;
   5538 
   5539 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   5540 	{
   5541 		os_error_printf(CU_MSG_INFO2, (PS8)"Enter Rx calibration has failed\n");
   5542 		return;
   5543 	}
   5544 
   5545 
   5546     if (TI_OK != data.testCmd_u.RxPlt.oRadioStatus) {
   5547 		os_error_printf(CU_MSG_INFO2, (PS8)"Enter Rx calibration returned status: %d\n", data.testCmd_u.RxPlt.oRadioStatus);
   5548 		return;
   5549 	}
   5550 
   5551 }
   5552 
   5553 
   5554 VOID CuCmd_BIP_StartRxBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5555 {
   5556 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5557     TTestCmd data;
   5558 
   5559 	os_memset(&data, 0, sizeof(TTestCmd));
   5560 
   5561     data.testCmdId = TEST_CMD_RX_PLT_CAL;
   5562     data.testCmd_u.RxPlt.iExternalSignalPowerLevel = (S32)parm[0].value;
   5563 
   5564     if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   5565     {
   5566         os_error_printf(CU_MSG_INFO2, (PS8)"Rx calibration has failed\n");
   5567         return;
   5568     }
   5569 
   5570     if (TI_OK != data.testCmd_u.RxPlt.oRadioStatus) {
   5571 		os_error_printf(CU_MSG_INFO2, (PS8)"Rx calibration returned status: %d\n", data.testCmd_u.RxPlt.oRadioStatus);
   5572 		return;
   5573 	}
   5574 
   5575 	nvsUpdateFile(hCuCmd, data.testCmd_u.RxPlt.oNvsStruct, (TI_UINT8)data.testCmd_u.RxPlt.oNVSVersion, NVS_FILE_RX_PARAMETERS_UPDATE);
   5576 }
   5577 
   5578 VOID CuCmd_BIP_ExitRxBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5579 {
   5580 	CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5581     TTestCmd data;
   5582 
   5583 	os_memset(&data, 0, sizeof(TTestCmd));
   5584 
   5585 	data.testCmdId = TEST_CMD_RX_PLT_EXIT;
   5586 
   5587 	if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data))
   5588 	{
   5589 		os_error_printf(CU_MSG_INFO2, (PS8)"Exit Rx calibration has failed\n");
   5590 		return;
   5591 	}
   5592 
   5593 
   5594     if (TI_OK != data.testCmd_u.RxPlt.oRadioStatus) {
   5595 		os_error_printf(CU_MSG_INFO2, (PS8)"Exit Rx calibration returned status: %d\n", data.testCmd_u.RxPlt.oRadioStatus);
   5596 		return;
   5597 	}
   5598 
   5599 }
   5600 
   5601 
   5602 
   5603 VOID CuCmd_SetPrivacyAuth(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5604 {
   5605     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5606     U32 AuthMode;
   5607 
   5608     if( nParms )
   5609     {
   5610         os_error_printf(CU_MSG_INFO2, (PS8)"Setting privacy authentication to %ld\n", parm[0].value);
   5611         AuthMode = parm[0].value;
   5612         if (pCuCmd->hWpaCore == NULL)
   5613         {
   5614             /* we can only accept WEP or OPEN configurations */
   5615             if((AuthMode >= os802_11AuthModeOpen) && (AuthMode <= os802_11AuthModeAutoSwitch))
   5616             {
   5617                 if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, AuthMode)) return;
   5618             }
   5619             else
   5620             {
   5621                 os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyAuth - cannot set mode (%ld) when Suppl is not present\n", AuthMode);
   5622                 return;
   5623             }
   5624         }
   5625         else
   5626         {
   5627 #ifndef NO_WPA_SUPPL
   5628             if(OK != WpaCore_SetAuthMode(pCuCmd->hWpaCore, AuthMode)) return;
   5629 #endif
   5630         }
   5631     }
   5632     else
   5633     {
   5634 #ifdef WPA_ENTERPRISE
   5635         static named_value_t auth_mode_type[] = {
   5636             { os802_11AuthModeOpen,             (PS8)"Open"      },
   5637             { os802_11AuthModeShared,           (PS8)"Shared"    },
   5638             { os802_11AuthModeAutoSwitch,       (PS8)"AutoSwitch"},
   5639             { os802_11AuthModeWPA,              (PS8)"WPA"       },
   5640             { os802_11AuthModeWPAPSK,           (PS8)"WPAPSK"    },
   5641             { os802_11AuthModeWPANone,          (PS8)"WPANone"   },
   5642             { os802_11AuthModeWPA2,             (PS8)"WPA2"      },
   5643             { os802_11AuthModeWPA2PSK,          (PS8)"WPA2PSK"   },
   5644         };
   5645 #else
   5646         static named_value_t auth_mode_type[] = {
   5647             { os802_11AuthModeOpen,             (PS8)"Open"      },
   5648             { os802_11AuthModeShared,           (PS8)"Shared"    },
   5649             { os802_11AuthModeWPAPSK,           (PS8)"WPAPSK"    },
   5650             { os802_11AuthModeWPA2PSK,          (PS8)"WPA2PSK"   },
   5651         };
   5652 #endif
   5653 
   5654         if (pCuCmd->hWpaCore == NULL)
   5655         {
   5656             if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, &AuthMode)) return;
   5657         }
   5658         else
   5659         {
   5660 #ifndef NO_WPA_SUPPL
   5661             if(OK != WpaCore_GetAuthMode(pCuCmd->hWpaCore, &AuthMode)) return;
   5662 #endif
   5663         }
   5664 
   5665         print_available_values(auth_mode_type);
   5666         os_error_printf(CU_MSG_INFO2, (PS8)"AuthenticationMode=%d\n", AuthMode );
   5667     }
   5668 }
   5669 
   5670 VOID CuCmd_SetPrivacyEap(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5671 {
   5672     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5673     OS_802_11_EAP_TYPES EapType;
   5674     S32 i;
   5675     named_value_t EapType_type[] = {
   5676         { OS_EAP_TYPE_NONE,                 (PS8)"OS_EAP_TYPE_NONE" },
   5677         { OS_EAP_TYPE_MD5_CHALLENGE,        (PS8)"OS_EAP_TYPE_MD5_CHALLENGE" },
   5678         { OS_EAP_TYPE_GENERIC_TOKEN_CARD,   (PS8)"OS_EAP_TYPE_GENERIC_TOKEN_CARD" },
   5679         { OS_EAP_TYPE_TLS,                  (PS8)"OS_EAP_TYPE_TLS" },
   5680         { OS_EAP_TYPE_LEAP,                 (PS8)"OS_EAP_TYPE_LEAP" },
   5681         { OS_EAP_TYPE_TTLS,                 (PS8)"OS_EAP_TYPE_TTLS" },
   5682         { OS_EAP_TYPE_PEAP,                 (PS8)"OS_EAP_TYPE_PEAP" },
   5683         { OS_EAP_TYPE_MS_CHAP_V2,           (PS8)"OS_EAP_TYPE_MS_CHAP_V2" },
   5684         { OS_EAP_TYPE_FAST,                 (PS8)"OS_EAP_TYPE_FAST" }
   5685     };
   5686 
   5687     /* check if we have supplicant */
   5688     if (pCuCmd->hWpaCore == NULL)
   5689     {
   5690         os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyEap - cannot set EapType when Suppl is not present\n");
   5691         return;
   5692     }
   5693 
   5694     if( nParms )
   5695     {
   5696         EapType = parm[0].value;
   5697         /* check if the param is valid */
   5698         CU_CMD_FIND_NAME_ARRAY(i, EapType_type, EapType);
   5699         if(i == SIZE_ARR(EapType_type))
   5700         {
   5701             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPrivacyEap, EapType %d is not defined!\n", EapType);
   5702             return;
   5703         }
   5704 
   5705 #ifndef NO_WPA_SUPPL
   5706 
   5707         if(OK != WpaCore_SetPrivacyEap(pCuCmd->hWpaCore, EapType))
   5708             os_error_printf(CU_MSG_INFO2, (PS8)"Error Setting EapType to %ld\n", EapType);
   5709         else
   5710             os_error_printf(CU_MSG_INFO2, (PS8)"Setting EapType to %ld\n", EapType);
   5711 
   5712 #endif
   5713                /*
   5714         WEXT phase I
   5715         TI_SetEAPType( g_id_adapter, (OS_802_11_EAP_TYPES) parm[0].value );
   5716         TI_SetEAPTypeDriver( g_id_adapter, (OS_802_11_EAP_TYPES) parm[0].value );
   5717         */
   5718 
   5719     }
   5720     else
   5721     {
   5722         print_available_values(EapType_type);
   5723     }
   5724 }
   5725 
   5726 
   5727 VOID CuCmd_SetPrivacyEncryption(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5728 {
   5729     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5730     U32 EncryptionType;
   5731 #ifndef NO_WPA_SUPPL
   5732     OS_802_11_ENCRYPTION_TYPES EncryptionTypePairWise;
   5733     OS_802_11_ENCRYPTION_TYPES EncryptionTypeGroup;
   5734 #endif
   5735     S32 i;
   5736 
   5737     if( nParms )
   5738     {
   5739         EncryptionType = parm[0].value;
   5740 
   5741         /* check if the param is valid */
   5742         CU_CMD_FIND_NAME_ARRAY(i, encrypt_type, EncryptionType);
   5743         if(i == SIZE_ARR(encrypt_type))
   5744         {
   5745             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPrivacyEncryption, EncryptionType %d is not defined!\n", EncryptionType);
   5746             return;
   5747         }
   5748 
   5749         if (pCuCmd->hWpaCore == NULL)
   5750         {
   5751             if((EncryptionType == OS_ENCRYPTION_TYPE_NONE) || (EncryptionType == OS_ENCRYPTION_TYPE_WEP))
   5752             {
   5753                 if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, RSN_ENCRYPTION_STATUS_PARAM, (U32)EncryptionType)) return;
   5754             }
   5755             else
   5756             {
   5757                 os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_SetPrivacyEncryption - can't set EncryptionType %s when not connected to supplicant",encrypt_type[i].name);
   5758                 return;
   5759             }
   5760         }
   5761         else
   5762         {
   5763 #ifndef NO_WPA_SUPPL
   5764             switch(EncryptionType)
   5765             {
   5766                 case OS_ENCRYPTION_TYPE_NONE:
   5767                     EncryptionTypePairWise = OS_ENCRYPTION_TYPE_NONE;
   5768                     EncryptionTypeGroup = OS_ENCRYPTION_TYPE_NONE;
   5769                     break;
   5770                 case OS_ENCRYPTION_TYPE_WEP:
   5771                     EncryptionTypePairWise = OS_ENCRYPTION_TYPE_WEP;
   5772                     EncryptionTypeGroup = OS_ENCRYPTION_TYPE_WEP;
   5773                     break;
   5774                 case OS_ENCRYPTION_TYPE_TKIP:
   5775                     EncryptionTypePairWise = OS_ENCRYPTION_TYPE_TKIP;
   5776                     EncryptionTypeGroup = OS_ENCRYPTION_TYPE_TKIP;
   5777                     break;
   5778                 case OS_ENCRYPTION_TYPE_AES:
   5779                     EncryptionTypePairWise = OS_ENCRYPTION_TYPE_AES;
   5780                     EncryptionTypeGroup = OS_ENCRYPTION_TYPE_AES;
   5781                     break;
   5782             }
   5783 
   5784             if(OK != WpaCore_SetEncryptionPairWise(pCuCmd->hWpaCore, EncryptionTypePairWise)) return;
   5785             if(OK != WpaCore_SetEncryptionGroup(pCuCmd->hWpaCore, EncryptionTypeGroup)) return;
   5786 #endif
   5787 
   5788         }
   5789 
   5790         os_error_printf(CU_MSG_INFO2, (PS8)"Setting privacy encryption to %ld\n", encrypt_type[i]);
   5791     }
   5792     else
   5793     {
   5794         if (pCuCmd->hWpaCore == NULL)
   5795         {
   5796             if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_ENCRYPTION_STATUS_PARAM, &EncryptionType)) return;
   5797 
   5798             switch (EncryptionType)
   5799             {
   5800             case TWD_CIPHER_NONE:
   5801                 EncryptionType = OS_ENCRYPTION_TYPE_NONE;
   5802                 break;
   5803             case TWD_CIPHER_WEP:
   5804             case TWD_CIPHER_WEP104:
   5805                 EncryptionType = OS_ENCRYPTION_TYPE_WEP;
   5806                 break;
   5807             case TWD_CIPHER_TKIP:
   5808                 EncryptionType = OS_ENCRYPTION_TYPE_TKIP;
   5809                 break;
   5810             case TWD_CIPHER_AES_WRAP:
   5811             case TWD_CIPHER_AES_CCMP:
   5812                 EncryptionType = OS_ENCRYPTION_TYPE_AES;
   5813                 break;
   5814             default:
   5815                 os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_SetPrivacyEncryption - unknown encryption type (%d)",EncryptionType);
   5816                 break;
   5817             }
   5818         }
   5819         else
   5820         {
   5821 #ifndef NO_WPA_SUPPL
   5822             if(OK != WpaCore_GetEncryptionPairWise(pCuCmd->hWpaCore, &EncryptionTypePairWise)) return;
   5823             if(OK != WpaCore_GetEncryptionGroup(pCuCmd->hWpaCore, &EncryptionTypeGroup)) return;
   5824 
   5825             if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_NONE) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_NONE))
   5826                 EncryptionType = OS_ENCRYPTION_TYPE_NONE;
   5827             else if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_WEP) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_WEP))
   5828                 EncryptionType = OS_ENCRYPTION_TYPE_WEP;
   5829             else if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_TKIP) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_TKIP))
   5830                 EncryptionType = OS_ENCRYPTION_TYPE_TKIP;
   5831             else if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_AES) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_AES))
   5832                 EncryptionType = OS_ENCRYPTION_TYPE_AES;
   5833             else
   5834             {
   5835                 os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_SetPrivacyEncryption - unknown encryption type (%d,%d)",EncryptionTypePairWise, EncryptionTypeGroup);
   5836                 return;
   5837             }
   5838 #endif
   5839         }
   5840 
   5841         print_available_values(encrypt_type);
   5842         os_error_printf(CU_MSG_INFO2, (PS8)"Encryption = %d\n", EncryptionType);
   5843     }
   5844 }
   5845 
   5846 VOID CuCmd_SetPrivacyKeyType(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5847 {
   5848     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5849     OS_802_11_KEY_TYPES KeyType;
   5850     S32 i;
   5851     static named_value_t KeyType_type[] = {
   5852             { OS_KEY_TYPE_STATIC,             (PS8)"STATIC" },
   5853             { OS_KEY_TYPE_DYNAMIC,            (PS8)"DYNAMIC"}
   5854     };
   5855 
   5856     /* check if we have supplicant */
   5857     if (pCuCmd->hWpaCore == NULL)
   5858     {
   5859         os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyEncryptGroup - cannot set encryption Group when Suppl is not present\n");
   5860         return;
   5861     }
   5862 
   5863     if( nParms )
   5864     {
   5865         KeyType = parm[0].value;
   5866         /* check if the param is valid */
   5867         CU_CMD_FIND_NAME_ARRAY(i, KeyType_type, KeyType);
   5868         if(i == SIZE_ARR(KeyType_type))
   5869         {
   5870             os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPrivacyKeyType - KeyType %d is not defined!\n", KeyType);
   5871             return;
   5872         }
   5873 
   5874         os_error_printf(CU_MSG_INFO2, (PS8)"Setting KeyType to %ld\n", KeyType);
   5875 
   5876          /*
   5877         WEXT phase I
   5878         TI_SetKeyType( g_id_adapter, (OS_802_11_KEY_TYPES)parm[0].value );
   5879         */
   5880     }
   5881     else
   5882     {
   5883         print_available_values(KeyType_type);
   5884     }
   5885 }
   5886 
   5887 VOID CuCmd_SetPrivacyMixedMode(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5888 {
   5889     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5890     U32 MixedMode;
   5891 
   5892     if( nParms )
   5893     {
   5894         MixedMode = parm[0].value;
   5895         os_error_printf(CU_MSG_INFO2, (PS8)"Setting MixedMode to %s\n", (MixedMode)?"True":"False");
   5896 
   5897         CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_MIXED_MODE_SET, MixedMode);
   5898     }
   5899     else
   5900     {
   5901         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_MIXED_MODE_GET, &MixedMode)) return;
   5902 
   5903         os_error_printf(CU_MSG_INFO2, (PS8)"Mixed Mode: 0 - FALSE, 1 - TRUE\n");
   5904         os_error_printf(CU_MSG_INFO2, (PS8)"Mixed Mode =%s\n", (MixedMode)?"True":"False");
   5905     }
   5906 }
   5907 
   5908 VOID CuCmd_SetPrivacyAnyWpaMode(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5909 {
   5910     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5911 #ifndef NO_WPA_SUPPL
   5912     U32 anyWpaMode;
   5913 
   5914     if( nParms )
   5915     {
   5916         anyWpaMode = parm[0].value;
   5917         os_error_printf(CU_MSG_INFO2, (PS8)"Setting anyWpaMode to %s\n", (anyWpaMode)?"True":"False");
   5918 
   5919         WpaCore_SetAnyWpaMode(pCuCmd->hWpaCore,(U8)anyWpaMode);
   5920     }
   5921     else
   5922     {
   5923 		WpaCore_GetAnyWpaMode(pCuCmd->hWpaCore,(U8 *)&anyWpaMode);
   5924         os_error_printf(CU_MSG_INFO2, (PS8)"Any WPA Mode: 0 - FALSE, 1 - TRUE\n");
   5925         os_error_printf(CU_MSG_INFO2, (PS8)"Any WPA =%s\n", (anyWpaMode)?"True":"False");
   5926     }
   5927 #else
   5928     os_error_printf(CU_MSG_INFO2, (PS8)"Any Wpa Mode support only in Linux supplicants\n");
   5929 #endif
   5930 }
   5931 
   5932 VOID CuCmd_SetPrivacyCredentials(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5933 {
   5934     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5935 
   5936     if( nParms == 0 )
   5937         return;
   5938 
   5939    if (pCuCmd->hWpaCore == NULL)
   5940    {
   5941        os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyPskPassPhrase - cannot set Credential password phrase when Suppl is not present\n");
   5942        return;
   5943    }
   5944 
   5945 #ifndef NO_WPA_SUPPL
   5946 
   5947      if( nParms == 2 )
   5948     {
   5949       WpaCore_SetCredentials(pCuCmd->hWpaCore,(PU8)(parm[0].value),(PU8)(parm[1].value));
   5950     }
   5951     else if( nParms == 1 )
   5952     {
   5953       WpaCore_SetCredentials(pCuCmd->hWpaCore,(PU8)(parm[0].value),NULL);
   5954     }
   5955 #endif
   5956 }
   5957 
   5958 VOID CuCmd_SetPrivacyPskPassPhrase(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   5959 {
   5960     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   5961     U32 IsHexKey = FALSE;
   5962     U8 buf[WPACORE_MAX_PSK_STRING_LENGTH];
   5963     PS8 pPassphrase;
   5964     S32 len;
   5965 
   5966     if( nParms == 0 )
   5967         return;
   5968 
   5969     /* check if we have supplicant */
   5970     if (pCuCmd->hWpaCore == NULL)
   5971     {
   5972         os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyPskPassPhrase - cannot set PSK password phrase when Suppl is not present\n");
   5973         return;
   5974     }
   5975 
   5976     len = os_strlen((PS8)(parm[0].value));
   5977     pPassphrase = ((PS8)parm[0].value);
   5978     os_memset(buf, 0, WPACORE_MAX_PSK_STRING_LENGTH);
   5979 
   5980 
   5981     if( nParms == 2 )
   5982     {
   5983         if( !os_strcmp( (PS8) parm[1].value, (PS8)"hex") )
   5984             IsHexKey = TRUE;
   5985         else if(!os_strcmp( (PS8) parm[1].value, (PS8)"text"))
   5986             IsHexKey = FALSE;
   5987     }
   5988 
   5989     if( IsHexKey )
   5990     {
   5991         U8 val_l;
   5992         U8 val_u;
   5993         S32 i;
   5994 
   5995         if( len != WPACORE_PSK_HEX_LENGTH )
   5996         {
   5997             os_error_printf(CU_MSG_INFO2, (PS8)"The hexa PSKPassphrase must be at length of %d hexa digits \n",WPACORE_PSK_HEX_LENGTH);
   5998             return;
   5999         }
   6000 
   6001         for( i=0; *pPassphrase; i++, pPassphrase++ )
   6002         {
   6003             val_u = CuCmd_Char2Hex(*pPassphrase);
   6004             if( val_u == ((U8)-1) ) return;
   6005             val_l = CuCmd_Char2Hex(*(++pPassphrase));
   6006             if( val_l == ((U8)-1) ) return;
   6007             buf[i] = ((val_u << 4) | val_l);
   6008         }
   6009     }
   6010     else
   6011     {
   6012         if (len > WPACORE_MAX_PSK_STRING_LENGTH || len < WPACORE_MIN_PSK_STRING_LENGTH)
   6013         {
   6014             os_error_printf(CU_MSG_INFO2, (PS8)"The PSKPassphrase must be between %d to  %d chars \n", WPACORE_MIN_PSK_STRING_LENGTH, WPACORE_MAX_PSK_STRING_LENGTH);
   6015             return;
   6016         }
   6017 
   6018         os_memcpy((PVOID)buf, (PVOID)pPassphrase, len);
   6019     }
   6020 
   6021     os_error_printf(CU_MSG_INFO2, (PS8)"Setting PSKPassphrase to %s\n", (PS8) parm[0].value);
   6022 #ifndef NO_WPA_SUPPL
   6023     WpaCore_SetPskPassPhrase(pCuCmd->hWpaCore, buf);
   6024 #endif
   6025 
   6026 }
   6027 
   6028 VOID CuCmd_SetPrivacyCertificate(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6029 {
   6030   CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6031 
   6032    if( nParms == 0 )
   6033         return;
   6034 
   6035    if (pCuCmd->hWpaCore == NULL)
   6036    {
   6037        os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyPskPassPhrase - cannot set Certification  when Suppl is not present\n");
   6038        return;
   6039    }
   6040 #ifndef NO_WPA_SUPPL
   6041    WpaCore_SetCertificate(pCuCmd->hWpaCore,(PU8)(parm[0].value));
   6042 #endif
   6043 
   6044 
   6045 }
   6046 
   6047 VOID CuCmd_StopSuppl(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6048 {
   6049     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6050 
   6051     /* check if we have supplicant */
   6052     if (pCuCmd->hWpaCore == NULL)
   6053     {
   6054         os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_StopSuppl - cannot stop supplicant when Suppl is not present :-)\n");
   6055         return;
   6056     }
   6057 #ifndef NO_WPA_SUPPL
   6058     WpaCore_StopSuppl(pCuCmd->hWpaCore);
   6059 #endif
   6060 }
   6061 
   6062 VOID CuCmd_ChangeSupplDebugLevels(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6063 {
   6064     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6065 
   6066     /* check if we have supplicant */
   6067     if (pCuCmd->hWpaCore == NULL)
   6068     {
   6069         os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_DebugSuppl - cannot debug supplicant when Suppl is not present :-)\n");
   6070         return;
   6071     }
   6072 #ifndef NO_WPA_SUPPL
   6073     WpaCore_ChangeSupplDebugLevels(pCuCmd->hWpaCore, parm[0].value, parm[1].value, parm[2].value);
   6074 #endif
   6075 }
   6076 
   6077 VOID CuCmd_AddPrivacyKey(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6078 {
   6079     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6080     PS8 buf;
   6081     U32 key_id = 0;
   6082     U32 def_flag = 0;
   6083     U32 IsHexKey = TRUE;
   6084     OS_802_11_WEP data;
   6085     U8 val_l, val_u;
   6086     S32 len;
   6087 
   6088     buf =  (PS8)parm[0].value;
   6089     key_id = (U32)parm[1].value;
   6090     if( parm[2].value ) def_flag = 0x80000000;
   6091     os_memset(data.KeyMaterial,0,sizeof(data.KeyMaterial));
   6092     len = os_strlen((PS8)buf);
   6093 
   6094     if(key_id > 3)
   6095     {
   6096         os_error_printf(CU_MSG_INFO2, (PS8)"the key index must be between 0 and 3\n");
   6097         return;
   6098     }
   6099 
   6100     if( nParms >= 4 )
   6101     {
   6102         if( !os_strcmp( (PS8) parm[3].value, (PS8)"hex") )
   6103             IsHexKey = TRUE;
   6104         else if( !os_strcmp( (PS8) parm[3].value, (PS8)"HEX") )
   6105             IsHexKey = TRUE;
   6106         else if(!os_strcmp( (PS8) parm[3].value, (PS8)"text"))
   6107             IsHexKey = FALSE;
   6108         else if(!os_strcmp( (PS8) parm[3].value, (PS8)"TEXT"))
   6109             IsHexKey = FALSE;
   6110     }
   6111 
   6112     if( IsHexKey )
   6113     {
   6114         S32 i;
   6115 
   6116         if( len % 2 )
   6117         {
   6118             os_error_printf(CU_MSG_INFO2, (PS8)"The hexa key should be even length\n");
   6119             return;
   6120         }
   6121         if(len <= 10) /*10 is number of character for key length 40 bit*/
   6122             data.KeyLength = 5;
   6123         else if(len <= 26) /*26 is number of character for key length 128 bit*/
   6124             data.KeyLength = 13;
   6125         else if(len <= 58) /*58 is number of character for key length 256 bit*/
   6126             data.KeyLength = 29;
   6127         else
   6128         {
   6129             os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddPrivacyKey - key length not valid\n" );
   6130             return;
   6131         }
   6132 
   6133         for( i=0; *buf; i++, buf++ )
   6134         {
   6135             val_u = CuCmd_Char2Hex(*buf);
   6136             if(val_u == ((U8)-1)) return;
   6137             val_l = CuCmd_Char2Hex(*(++buf));
   6138             if(val_l == ((U8)-1)) return;
   6139             data.KeyMaterial[i] = ((val_u << 4) | val_l);
   6140         }
   6141     }
   6142     else /* for ascii key */
   6143     {
   6144         if(len <= 5) /*10 is number of character for key length 40 bit*/
   6145             data.KeyLength = 5;
   6146         else if(len <= 13) /*26 is number of character for key length 128 bit*/
   6147             data.KeyLength = 13;
   6148         else if(len <= 29) /*58 is number of character for key length 256 bit*/
   6149             data.KeyLength = 29;
   6150         else
   6151         {
   6152             os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddPrivacyKey - key length not valid\n" );
   6153             return;
   6154         }
   6155         os_memcpy((PVOID)data.KeyMaterial, (PVOID)buf, len);
   6156     }
   6157 
   6158     data.KeyIndex = def_flag | key_id;
   6159     data.Length = sizeof(OS_802_11_WEP);
   6160 
   6161     /* check if we have supplicant */
   6162     if (pCuCmd->hWpaCore == NULL)
   6163     {
   6164         CuCommon_AddKey(pCuCmd->hCuCommon, &data);
   6165     }
   6166     else
   6167     {
   6168 #ifndef NO_WPA_SUPPL
   6169         WpaCore_AddKey(pCuCmd->hWpaCore, &data);
   6170 #endif
   6171     }
   6172 }
   6173 
   6174 VOID CuCmd_RemovePrivacyKey(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6175 {
   6176     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6177 
   6178     /* check if we have supplicant */
   6179     CuCommon_RemoveKey(pCuCmd->hCuCommon, parm[0].value);
   6180 }
   6181 
   6182 VOID CuCmd_GetPrivacyDefaultKey(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6183 {
   6184     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6185     U32 DefaultKeyId;
   6186 
   6187     /* check if we have supplicant */
   6188     if (pCuCmd->hWpaCore == NULL)
   6189     {
   6190         if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_DEFAULT_KEY_ID, &DefaultKeyId)) return;
   6191     }
   6192     else
   6193     {
   6194 #ifndef NO_WPA_SUPPL
   6195         if(OK != WpaCore_GetDefaultKey(pCuCmd->hWpaCore, &DefaultKeyId)) return;
   6196 #endif
   6197     }
   6198 
   6199     os_error_printf(CU_MSG_INFO2, (PS8)"WEP default key ID = %d\n", DefaultKeyId );
   6200 }
   6201 
   6202 VOID CuCmd_EnableKeepAlive (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6203 {
   6204     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6205 
   6206     if (OK != CuCommon_SetU32 (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ENA_DIS, 1))
   6207     {
   6208         os_error_printf (CU_MSG_ERROR, (PS8)"Unable to enable keep-alive messages\n");
   6209     }
   6210 }
   6211 
   6212 VOID CuCmd_DisableKeepAlive (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6213 {
   6214     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6215 
   6216     if (OK != CuCommon_SetU32 (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ENA_DIS, 0))
   6217     {
   6218         os_error_printf (CU_MSG_ERROR, (PS8)"Unable to disable keep-alive messages\n");
   6219     }
   6220 }
   6221 
   6222 VOID CuCmd_AddKeepAliveMessage (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6223 {
   6224     CuCmd_t                 *pCuCmd = (CuCmd_t*)hCuCmd;
   6225     TKeepAliveTemplate      keepAliveParams;
   6226 
   6227     if (4 != nParms)
   6228     {
   6229         os_error_printf (CU_MSG_ERROR, (PS8)"Number of params to add keep-alive message is %d\n", nParms);
   6230         return;
   6231     }
   6232 
   6233     /* copy keep-alive params */
   6234     keepAliveParams.keepAliveParams.index = (U8)parm[ 0 ].value;
   6235     keepAliveParams.keepAliveParams.interval = parm[ 1 ].value;
   6236     keepAliveParams.keepAliveParams.trigType = parm[ 2 ].value;
   6237     keepAliveParams.keepAliveParams.enaDisFlag = 1; /* set to enable */
   6238     keepAliveParams.msgBufferLength = os_strlen ((PS8)parm[ 3 ].value);
   6239     if (0 == (keepAliveParams.msgBufferLength %2))
   6240     {
   6241         keepAliveParams.msgBufferLength = keepAliveParams.msgBufferLength / 2;
   6242     }
   6243     else
   6244     {
   6245         keepAliveParams.msgBufferLength = (keepAliveParams.msgBufferLength / 2) + 1;
   6246     }
   6247     /* convert the string to hexadeciaml values, and copy it */
   6248     CuCmd_atox_string ((U8*)parm[ 3 ].value, &keepAliveParams.msgBuffer[ 0 ]);
   6249 
   6250     if (TI_OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ADD_REM,
   6251                                     &(keepAliveParams), sizeof(TKeepAliveTemplate)))
   6252     {
   6253         os_error_printf (CU_MSG_ERROR, (PS8)"Unable to add keep-alive message\n");
   6254     }
   6255 }
   6256 
   6257 VOID CuCmd_RemoveKeepAliveMessage (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6258 {
   6259     CuCmd_t                 *pCuCmd = (CuCmd_t*)hCuCmd;
   6260     TKeepAliveTemplate      keepAliveParams;
   6261 
   6262     if (1 != nParms)
   6263     {
   6264         os_error_printf (CU_MSG_ERROR, (PS8)"Number of params to remove keep-alive message is %d\n", nParms);
   6265         return;
   6266     }
   6267 
   6268     /* copy keep-alive params */
   6269     keepAliveParams.keepAliveParams.index = (U8)parm[ 0 ].value;
   6270     keepAliveParams.keepAliveParams.enaDisFlag = 0; /* set to disable */
   6271     keepAliveParams.keepAliveParams.interval = 1000; /* FW validate all parameters, so some reasonable values must be used */
   6272     keepAliveParams.keepAliveParams.trigType = KEEP_ALIVE_TRIG_TYPE_PERIOD_ONLY;
   6273 
   6274     if (OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ADD_REM,
   6275                                   &(keepAliveParams), sizeof(TKeepAliveTemplate)))
   6276     {
   6277         os_error_printf (CU_MSG_ERROR, (PS8)"Unable to remove keep-alive message\n");
   6278     }
   6279 }
   6280 
   6281 VOID CuCmd_ShowKeepAlive (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6282 {
   6283     CuCmd_t                 *pCuCmd = (CuCmd_t*)hCuCmd;
   6284     TKeepAliveConfig        tConfig;
   6285     U32                     uIndex, uNameIndex;
   6286     S8                      msgBuffer[ KEEP_ALIVE_TEMPLATE_MAX_LENGTH * 2 ];
   6287 
   6288     if (OK != CuCommon_GetSetBuffer (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_GET_CONFIG,
   6289                                      &(tConfig), sizeof(TKeepAliveConfig)))
   6290     {
   6291         os_error_printf (CU_MSG_ERROR, (PS8)"Unable to read keep-alive configuration\n");
   6292     }
   6293 
   6294     os_error_printf (CU_MSG_ERROR, (PS8)"Keep-Alive configuration:\n"
   6295                                    "-------------------------\n");
   6296     if (TRUE == tConfig.enaDisFlag)
   6297     {
   6298         os_error_printf (CU_MSG_ERROR, (PS8)"Keep-Alive global flag set to enabled\n\n");
   6299     }
   6300     else
   6301     {
   6302         os_error_printf (CU_MSG_ERROR, (PS8)"Keep-Alive global flag set to disabled\n\n");
   6303     }
   6304 
   6305     os_error_printf (CU_MSG_ERROR, (PS8)"%-8s %-8s %-9s %-10s %s\n", (PS8)"Index", (PS8)"Enabled", (PS8)"Trig Type", (PS8)"Interval", (PS8)"Pattern");
   6306     os_error_printf (CU_MSG_ERROR, (PS8)"-----------------------------------------------\n");
   6307     for (uIndex = 0; uIndex < KEEP_ALIVE_MAX_USER_MESSAGES; uIndex++)
   6308     {
   6309         if (TRUE == tConfig.templates[ uIndex ].keepAliveParams.enaDisFlag)
   6310         {
   6311             CU_CMD_FIND_NAME_ARRAY (uNameIndex, tKeepAliveTriggerTypes,
   6312                                     tConfig.templates[ uIndex ].keepAliveParams.trigType);
   6313             CuCmd_xtoa_string (&(tConfig.templates[ uIndex ].msgBuffer[ 0 ]),
   6314                                tConfig.templates[ uIndex ].msgBufferLength, (U8*)&(msgBuffer[ 0 ]));
   6315                              os_error_printf (CU_MSG_ERROR, (PS8)"%-8d %-8d %-9s %-10d %s\n", uIndex,
   6316                              tConfig.templates[ uIndex ].keepAliveParams.enaDisFlag,
   6317                              tKeepAliveTriggerTypes[ uNameIndex ].name,
   6318                              tConfig.templates[ uIndex ].keepAliveParams.interval,
   6319                              &(msgBuffer[ 0 ]));
   6320         }
   6321         else
   6322         {
   6323             os_error_printf (CU_MSG_ERROR, (PS8)"%-8d %-8d %-9s %-10d %s\n", uIndex, 0, (PS8)"N/A", 0, (PS8)"N/A");
   6324         }
   6325     }
   6326 }
   6327 
   6328 
   6329 VOID CuCmd_SetArpIPFilter (THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6330 {
   6331 
   6332     TIpAddr     staIp;
   6333     CuCmd_t     *pCuCmd = (CuCmd_t*)hCuCmd;
   6334     TI_UINT8    length = 4;
   6335 
   6336     if (length != nParms)
   6337     {
   6338         os_error_printf (CU_MSG_ERROR, (PS8)"Error! IP format requires 4 parameters as follows: <Part1> <Part2> <Part3> <Part4>  \n");
   6339         os_error_printf (CU_MSG_ERROR, (PS8)"Please note! IP of 0 0 0 0 will disable the arp filtering feature \n");
   6340         return;
   6341     }
   6342 
   6343     staIp[0] = (TI_UINT8)parm[0].value;
   6344     staIp[1] = (TI_UINT8)parm[1].value;
   6345     staIp[2] = (TI_UINT8)parm[2].value;
   6346     staIp[3] = (TI_UINT8)parm[3].value;
   6347 
   6348 
   6349      if (OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, SITE_MGR_SET_WLAN_IP_PARAM, staIp, length))
   6350     {
   6351         os_error_printf (CU_MSG_ERROR, (PS8)"Unable to configure ARP IP filter \n");
   6352     }
   6353 
   6354 }
   6355 
   6356 VOID CuCmd_ShowAbout(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6357 {
   6358     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6359     S8 FwVesrion[FW_VERSION_LEN];
   6360 
   6361     if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, SITE_MGR_FIRMWARE_VERSION_PARAM,
   6362         FwVesrion, FW_VERSION_LEN)) return;
   6363 
   6364 #ifdef XCC_MODULE_INCLUDED
   6365     os_error_printf(CU_MSG_INFO2, (PS8)"Driver version: %s_XCC\n",
   6366                                                 SW_VERSION_STR);
   6367 #elif GEM_SUPPORTED
   6368     os_error_printf(CU_MSG_INFO2, (PS8)"Driver version: %s_GEM\n",
   6369                                                 SW_VERSION_STR);
   6370 #else
   6371     os_error_printf(CU_MSG_INFO2, (PS8)"Driver version: %s_NOCCX\n",
   6372                                                 SW_VERSION_STR);
   6373 #endif/* XCC_MODULE_INCLUDED*/
   6374     os_error_printf(CU_MSG_INFO2, (PS8)"Firmware version: %s\n",
   6375                                                 FwVesrion);
   6376 
   6377 }
   6378 
   6379 VOID CuCmd_Quit(THandle hCuCmd, ConParm_t parm[], U16 nParms)
   6380 {
   6381     CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
   6382 
   6383     Console_Stop(pCuCmd->hConsole);
   6384 }
   6385 
   6386 
   6387