| /* |
| * cu_cmd.c |
| * |
| * Copyright 2001-2010 Texas Instruments, Inc. - http://www.ti.com/ |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /**************************************************************************** |
| * |
| * MODULE: cu_cmd.c |
| * |
| * PURPOSE: |
| * |
| * DESCRIPTION: |
| * ============ |
| * |
| * |
| ****************************************************************************/ |
| |
| /* includes */ |
| /************/ |
| |
| #include <stdio.h> |
| |
| #include "cu_osapi.h" |
| #include "TWDriver.h" |
| #include "convert.h" |
| #include "console.h" |
| #include "cu_common.h" |
| #include "cu_os.h" |
| #include "ipc_event.h" |
| #include "wpa_core.h" |
| #include "cu_cmd.h" |
| #include "oserr.h" |
| |
| /* defines */ |
| /***********/ |
| #define print_available_values(arr) \ |
| { \ |
| S32 i; \ |
| for(i=0; i<SIZE_ARR(arr); i++) \ |
| os_error_printf(CU_MSG_INFO2, (PS8)"%d - %s%s", arr[i].value, arr[i].name, (i>=SIZE_ARR(arr)-1) ? (PS8)"\n" : (PS8)", " ); \ |
| } |
| |
| #define CU_CMD_FIND_NAME_ARRAY(index, arr, val) \ |
| for ( index = 0; index < SIZE_ARR(arr); index++ ) \ |
| if ( arr[ index ].value == (val) ) \ |
| break; \ |
| |
| #define CHAN_FREQ_TABLE_SIZE (sizeof(ChanFreq) / sizeof(struct CHAN_FREQ)) |
| |
| #define IS_BASIC_RATE(a) ((a) & NET_BASIC_MASK) |
| |
| #define RATE_2_MBPS(a) ((F32)((a) & (NET_BASIC_MASK-1))/2) |
| |
| #define NET_BASIC_MASK 0x80 /* defined in common/src/utils/utils.c */ |
| |
| #define BIT_TO_BYTE_FACTOR 8 |
| |
| #define NVS_FILE_TX_PARAMETERS_UPDATE 0 |
| #define NVS_FILE_RX_PARAMETERS_UPDATE 1 |
| |
| |
| /* local types */ |
| /***************/ |
| /* Module control block */ |
| typedef struct CuCmd_t |
| { |
| THandle hCuWext; |
| THandle hCuCommon; |
| THandle hConsole; |
| THandle hIpcEvent; |
| THandle hWpaCore; |
| |
| U32 isDeviceRunning; |
| |
| scan_Params_t appScanParams; |
| TPeriodicScanParams tPeriodicAppScanParams; |
| scan_Policy_t scanPolicy; |
| |
| } CuCmd_t; |
| |
| /* local variables */ |
| /*******************/ |
| struct CHAN_FREQ { |
| U8 chan; |
| U32 freq; |
| } ChanFreq[] = { |
| {1,2412000}, {2,2417000}, {3,2422000}, {4,2427000}, |
| {5,2432000}, {6,2437000}, {7,2442000}, {8,2447000}, |
| {9,2452000}, |
| {10,2457000}, {11,2462000}, {12,2467000}, {13,2472000}, |
| {14,2484000}, {36,5180000}, {40,5200000}, {44,5220000}, |
| {48,5240000}, {52,5260000}, {56,5280000}, {60,5300000}, |
| {64,5320000}, |
| {100,5500000}, {104,5520000}, {108,5540000}, {112,5560000}, |
| {116,5580000}, {120,5600000}, {124,5620000}, {128,5640000}, |
| {132,5660000}, {136,5680000}, {140,5700000}, {149,5745000}, |
| {153,5765000}, {157,5785000}, {161,5805000} }; |
| |
| static named_value_t BSS_type[] = |
| { |
| { os802_11IBSS, (PS8)"AD-Hoc" }, |
| { os802_11Infrastructure, (PS8)"Infr." }, |
| { os802_11AutoUnknown, (PS8)"Auto" }, |
| }; |
| |
| static named_value_t Current_mode[] = |
| { |
| { 0, (PS8)"SME Auto" }, |
| { 1, (PS8)"SME Manual" }, |
| }; |
| |
| static named_value_t BeaconFilter_use[] = |
| { |
| { 0, (PS8)"INACTIVE" }, |
| { 1, (PS8)"ACTIVE" }, |
| }; |
| |
| static named_value_t event_type[] = { |
| { IPC_EVENT_ASSOCIATED, (PS8)"Associated" }, |
| { IPC_EVENT_DISASSOCIATED, (PS8)"Disassociated" }, |
| { IPC_EVENT_LINK_SPEED, (PS8)"LinkSpeed" }, |
| { IPC_EVENT_AUTH_SUCC, (PS8)"Authentication Success" }, |
| { IPC_EVENT_SCAN_COMPLETE, (PS8)"ScanComplete" }, |
| { IPC_EVENT_SCAN_STOPPED, (PS8)"ScanStopped" }, |
| #ifdef XCC_MODULE_INCLUDED |
| { IPC_EVENT_CCKM_START, (PS8)"CCKM_Start" }, |
| #endif |
| { IPC_EVENT_MEDIA_SPECIFIC, (PS8)"Media_Specific" }, |
| { IPC_EVENT_EAPOL, (PS8)"EAPOL" }, |
| { IPC_EVENT_RE_AUTH_STARTED, (PS8)"IPC_EVENT_RE_AUTH_STARTED" }, |
| { IPC_EVENT_RE_AUTH_COMPLETED, (PS8)"IPC_EVENT_RE_AUTH_COMPLETED" }, |
| { IPC_EVENT_RE_AUTH_TERMINATED, (PS8)"IPC_EVENT_RE_AUTH_TERMINATED" }, |
| { IPC_EVENT_BOUND, (PS8)"Bound" }, |
| { IPC_EVENT_UNBOUND, (PS8)"Unbound" }, |
| #ifdef WPA_ENTERPRISE |
| { IPC_EVENT_PREAUTH_EAPOL, (PS8)"PreAuth EAPOL"}, |
| #endif |
| { IPC_EVENT_LOW_RSSI, (PS8)"Low RSSI" }, |
| { IPC_EVENT_TSPEC_STATUS, (PS8)"IPC_EVENT_TSPEC_STATUS" }, |
| { IPC_EVENT_TSPEC_RATE_STATUS, (PS8)"IPC_EVENT_TSPEC_RATE_STATUS" }, |
| { IPC_EVENT_MEDIUM_TIME_CROSS, (PS8)"IPC_EVENT_MEDIUM_TIME_CROSS" }, |
| { IPC_EVENT_ROAMING_COMPLETE, (PS8)"ROAMING_COMPLETE"}, |
| { IPC_EVENT_EAP_AUTH_FAILURE, (PS8)"EAP-FAST/LEAP Auth Failed"}, |
| { IPC_EVENT_WPA2_PREAUTHENTICATION, (PS8)"IPC_EVENT_WPA2_PREAUTHENTICATION" }, |
| { IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, (PS8)"IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED" }, |
| { IPC_EVENT_SCAN_FAILED, (PS8)"ScanFailed" }, |
| { IPC_EVENT_WPS_SESSION_OVERLAP, (PS8)"IPC_EVENT_WPS_SESSION_OVERLAP" }, |
| { IPC_EVENT_RSSI_SNR_TRIGGER, (PS8)"IPC_EVENT_RSSI_SNR_TRIGGER" }, |
| { IPC_EVENT_TIMEOUT, (PS8)"Timeout" } |
| }; |
| |
| static named_value_t report_module[] = |
| { |
| { FILE_ID_0 , (PS8)"timer " }, |
| { FILE_ID_1 , (PS8)"measurementMgr " }, |
| { FILE_ID_2 , (PS8)"measurementMgrSM " }, |
| { FILE_ID_3 , (PS8)"regulatoryDomain " }, |
| { FILE_ID_4 , (PS8)"requestHandler " }, |
| { FILE_ID_5 , (PS8)"SoftGemini " }, |
| { FILE_ID_6 , (PS8)"spectrumMngmntMgr " }, |
| { FILE_ID_7 , (PS8)"SwitchChannel " }, |
| { FILE_ID_8 , (PS8)"roamingMngr " }, |
| { FILE_ID_9 , (PS8)"scanMngr " }, |
| { FILE_ID_10 , (PS8)"admCtrlXCC " }, |
| { FILE_ID_11 , (PS8)"XCCMngr " }, |
| { FILE_ID_12 , (PS8)"XCCRMMngr " }, |
| { FILE_ID_13 , (PS8)"XCCTSMngr " }, |
| { FILE_ID_14 , (PS8)"rogueAp " }, |
| { FILE_ID_15 , (PS8)"TransmitPowerXCC " }, |
| { FILE_ID_16 , (PS8)"admCtrl " }, |
| { FILE_ID_17 , (PS8)"admCtrlNone " }, |
| { FILE_ID_18 , (PS8)"admCtrlWep " }, |
| { FILE_ID_19 , (PS8)"admCtrlWpa " }, |
| { FILE_ID_20 , (PS8)"admCtrlWpa2 " }, |
| { FILE_ID_21 , (PS8)"apConn " }, |
| { FILE_ID_22 , (PS8)"broadcastKey802_1x " }, |
| { FILE_ID_23 , (PS8)"broadcastKeyNone " }, |
| { FILE_ID_24 , (PS8)"broadcastKeySM " }, |
| { FILE_ID_25 , (PS8)"conn " }, |
| { FILE_ID_26 , (PS8)"connIbss " }, |
| { FILE_ID_27 , (PS8)"connInfra " }, |
| { FILE_ID_28 , (PS8)"keyDerive " }, |
| { FILE_ID_29 , (PS8)"keyDeriveAes " }, |
| { FILE_ID_30 , (PS8)"keyDeriveCkip " }, |
| { FILE_ID_31 , (PS8)"keyDeriveTkip " }, |
| { FILE_ID_32 , (PS8)"keyDeriveWep " }, |
| { FILE_ID_33 , (PS8)"keyParser " }, |
| { FILE_ID_34 , (PS8)"keyParserExternal " }, |
| { FILE_ID_35 , (PS8)"keyParserWep " }, |
| { FILE_ID_36 , (PS8)"mainKeysSm " }, |
| { FILE_ID_37 , (PS8)"mainSecKeysOnly " }, |
| { FILE_ID_38 , (PS8)"mainSecNull " }, |
| { FILE_ID_39 , (PS8)"mainSecSm " }, |
| { FILE_ID_40 , (PS8)"rsn " }, |
| { FILE_ID_41 , (PS8)"sme " }, |
| { FILE_ID_42 , (PS8)"smeSelect " }, |
| { FILE_ID_43 , (PS8)"smeSm " }, |
| { FILE_ID_44 , (PS8)"unicastKey802_1x " }, |
| { FILE_ID_45 , (PS8)"unicastKeyNone " }, |
| { FILE_ID_46 , (PS8)"unicastKeySM " }, |
| { FILE_ID_47 , (PS8)"CmdDispatcher " }, |
| { FILE_ID_48 , (PS8)"CmdHndlr " }, |
| { FILE_ID_49 , (PS8)"DrvMain " }, |
| { FILE_ID_50 , (PS8)"EvHandler " }, |
| { FILE_ID_51 , (PS8)"Ctrl " }, |
| { FILE_ID_52 , (PS8)"GeneralUtil " }, |
| { FILE_ID_53 , (PS8)"RateAdaptation " }, |
| { FILE_ID_54 , (PS8)"rx " }, |
| { FILE_ID_55 , (PS8)"TrafficMonitor " }, |
| { FILE_ID_56 , (PS8)"txCtrl " }, |
| { FILE_ID_57 , (PS8)"txCtrlParams " }, |
| { FILE_ID_58 , (PS8)"txCtrlServ " }, |
| { FILE_ID_59 , (PS8)"TxDataClsfr " }, |
| { FILE_ID_60 , (PS8)"txDataQueue " }, |
| { FILE_ID_61 , (PS8)"txMgmtQueue " }, |
| { FILE_ID_62 , (PS8)"txPort " }, |
| { FILE_ID_63 , (PS8)"assocSM " }, |
| { FILE_ID_64 , (PS8)"authSm " }, |
| { FILE_ID_65 , (PS8)"currBss " }, |
| { FILE_ID_66 , (PS8)"healthMonitor " }, |
| { FILE_ID_67 , (PS8)"mlmeBuilder " }, |
| { FILE_ID_68 , (PS8)"mlmeParser " }, |
| { FILE_ID_69 , (PS8)"mlmeSm " }, |
| { FILE_ID_70 , (PS8)"openAuthSm " }, |
| { FILE_ID_71 , (PS8)"PowerMgr " }, |
| { FILE_ID_72 , (PS8)"PowerMgrDbgPrint " }, |
| { FILE_ID_73 , (PS8)"PowerMgrKeepAlive " }, |
| { FILE_ID_74 , (PS8)"qosMngr " }, |
| { FILE_ID_75 , (PS8)"roamingInt " }, |
| { FILE_ID_76 , (PS8)"ScanCncn " }, |
| { FILE_ID_77 , (PS8)"ScanCncnApp " }, |
| { FILE_ID_78 , (PS8)"ScanCncnOsSm " }, |
| { FILE_ID_79 , (PS8)"ScanCncnSm " }, |
| { FILE_ID_80 , (PS8)"ScanCncnSmSpecific " }, |
| { FILE_ID_81 , (PS8)"scanResultTable " }, |
| { FILE_ID_82 , (PS8)"scr " }, |
| { FILE_ID_83 , (PS8)"sharedKeyAuthSm " }, |
| { FILE_ID_84 , (PS8)"siteHash " }, |
| { FILE_ID_85 , (PS8)"siteMgr " }, |
| { FILE_ID_86 , (PS8)"StaCap " }, |
| { FILE_ID_87 , (PS8)"systemConfig " }, |
| { FILE_ID_88 , (PS8)"templates " }, |
| { FILE_ID_89 , (PS8)"trafficAdmControl " }, |
| { FILE_ID_90 , (PS8)"CmdBld " }, |
| { FILE_ID_91 , (PS8)"CmdBldCfg " }, |
| { FILE_ID_92 , (PS8)"CmdBldCfgIE " }, |
| { FILE_ID_93 , (PS8)"CmdBldCmd " }, |
| { FILE_ID_94 , (PS8)"CmdBldCmdIE " }, |
| { FILE_ID_95 , (PS8)"CmdBldItr " }, |
| { FILE_ID_96 , (PS8)"CmdBldItrIE " }, |
| { FILE_ID_97 , (PS8)"CmdQueue " }, |
| { FILE_ID_98 , (PS8)"RxQueue " }, |
| { FILE_ID_99 , (PS8)"txCtrlBlk " }, |
| { FILE_ID_100 , (PS8)"txHwQueue " }, |
| { FILE_ID_101 , (PS8)"CmdMBox " }, |
| { FILE_ID_102 , (PS8)"eventMbox " }, |
| { FILE_ID_103 , (PS8)"fwDebug " }, |
| { FILE_ID_104 , (PS8)"FwEvent " }, |
| { FILE_ID_105 , (PS8)"HwInit " }, |
| { FILE_ID_106 , (PS8)"RxXfer " }, |
| { FILE_ID_107 , (PS8)"txResult " }, |
| { FILE_ID_108 , (PS8)"txXfer " }, |
| { FILE_ID_109 , (PS8)"MacServices " }, |
| { FILE_ID_110 , (PS8)"MeasurementSrv " }, |
| { FILE_ID_111 , (PS8)"measurementSrvDbgPrint " }, |
| { FILE_ID_112 , (PS8)"MeasurementSrvSM " }, |
| { FILE_ID_113 , (PS8)"PowerSrv " }, |
| { FILE_ID_114 , (PS8)"PowerSrvSM " }, |
| { FILE_ID_115 , (PS8)"ScanSrv " }, |
| { FILE_ID_116 , (PS8)"ScanSrvSM " }, |
| { FILE_ID_117 , (PS8)"TWDriver " }, |
| { FILE_ID_118 , (PS8)"TWDriverCtrl " }, |
| { FILE_ID_119 , (PS8)"TWDriverRadio " }, |
| { FILE_ID_120 , (PS8)"TWDriverTx " }, |
| { FILE_ID_121 , (PS8)"TwIf " }, |
| { FILE_ID_122 , (PS8)"SdioBusDrv " }, |
| { FILE_ID_123 , (PS8)"TxnQueue " }, |
| { FILE_ID_124 , (PS8)"WspiBusDrv " }, |
| { FILE_ID_125 , (PS8)"context " }, |
| { FILE_ID_126 , (PS8)"freq " }, |
| { FILE_ID_127 , (PS8)"fsm " }, |
| { FILE_ID_128 , (PS8)"GenSM " }, |
| { FILE_ID_129 , (PS8)"mem " }, |
| { FILE_ID_130 , (PS8)"queue " }, |
| { FILE_ID_131 , (PS8)"rate " }, |
| { FILE_ID_132 , (PS8)"report " }, |
| { FILE_ID_133 , (PS8)"stack " }, |
| { FILE_ID_134 , (PS8)"externalSec " }, |
| { FILE_ID_135 , (PS8)"roamingMngr_autoSM " }, |
| { FILE_ID_136 , (PS8)"roamingMngr_manualSM " }, |
| { FILE_ID_137 , (PS8)"cmdinterpretoid " }, |
| { FILE_ID_138 , (PS8)"WlanDrvIf " } |
| }; |
| |
| static named_value_t report_severity[] = { |
| { 0, (PS8)"----" }, |
| { REPORT_SEVERITY_INIT, (PS8)"INIT", }, |
| { REPORT_SEVERITY_INFORMATION, (PS8)"INFORMATION", }, |
| { REPORT_SEVERITY_WARNING, (PS8)"WARNING", }, |
| { REPORT_SEVERITY_ERROR, (PS8)"ERROR", }, |
| { REPORT_SEVERITY_FATAL_ERROR, (PS8)"FATAL_ERROR", }, |
| { REPORT_SEVERITY_SM, (PS8)"SM", }, |
| { REPORT_SEVERITY_CONSOLE, (PS8)"CONSOLE" } |
| }; |
| |
| static named_value_t power_level[] = { |
| { OS_POWER_LEVEL_ELP, (PS8)"Extreme Low Power" }, |
| { OS_POWER_LEVEL_PD, (PS8)"Power Down" }, |
| { OS_POWER_LEVEL_AWAKE, (PS8)"Awake" }, |
| }; |
| |
| static named_value_t band2Str[] = { |
| { RADIO_BAND_2_4_GHZ, (PS8)"2.4 GHz" }, |
| { RADIO_BAND_5_0_GHZ, (PS8)"5.0 GHz" }, |
| { RADIO_BAND_DUAL, (PS8)"Both " } |
| }; |
| |
| static named_value_t EtEvent2Str[] = { |
| { SCAN_ET_COND_DISABLE, (PS8)"ET disabled " }, |
| { SCAN_ET_COND_BEACON, (PS8)"ET on Beacon " }, |
| { SCAN_ET_COND_PROBE_RESP, (PS8)"ET on Prb Rsp" }, |
| { SCAN_ET_COND_ANY_FRAME, (PS8)"ET on both " } |
| }; |
| |
| static named_value_t rate2Str[] = { |
| { DRV_RATE_MASK_AUTO, (PS8)"Auto " }, |
| { DRV_RATE_MASK_1_BARKER, (PS8)"1 Mbps " }, |
| { DRV_RATE_MASK_2_BARKER, (PS8)"2 Mbps " }, |
| { DRV_RATE_MASK_5_5_CCK, (PS8)"5.5 Mbps" }, |
| { DRV_RATE_MASK_11_CCK, (PS8)"11 Mbps " }, |
| { DRV_RATE_MASK_22_PBCC, (PS8)"22 Mbps " }, |
| { DRV_RATE_MASK_6_OFDM, (PS8)"6 Mbps " }, |
| { DRV_RATE_MASK_9_OFDM, (PS8)"9 Mbps " }, |
| { DRV_RATE_MASK_12_OFDM, (PS8)"12 Mbps " }, |
| { DRV_RATE_MASK_18_OFDM, (PS8)"18 Mbps " }, |
| { DRV_RATE_MASK_24_OFDM, (PS8)"24 Mbps " }, |
| { DRV_RATE_MASK_36_OFDM, (PS8)"36 Mbps " }, |
| { DRV_RATE_MASK_48_OFDM, (PS8)"48 Mbps " }, |
| { DRV_RATE_MASK_54_OFDM, (PS8)"54 Mbps " } |
| }; |
| |
| static named_value_t scanType2Str[] = { |
| { SCAN_TYPE_NORMAL_PASSIVE, (PS8)"Passive Normal Scan" }, |
| { SCAN_TYPE_NORMAL_ACTIVE, (PS8)"Active Normal Scan" }, |
| { SCAN_TYPE_SPS, (PS8)"Scheduled Passive Scan (SPS)" }, |
| { SCAN_TYPE_TRIGGERED_PASSIVE, (PS8)"Passive Triggered Scan" }, |
| { SCAN_TYPE_TRIGGERED_ACTIVE, (PS8)"Active Triggered Scan" } |
| }; |
| |
| static named_value_t booleanStr[] = { |
| { FALSE, (PS8)"False" }, |
| { TRUE, (PS8)"True" } |
| }; |
| |
| static named_value_t ssidVisabilityStr[] = { |
| { SCAN_SSID_VISABILITY_PUBLIC, (PS8)"Public" }, |
| { SCAN_SSID_VISABILITY_HIDDEN, (PS8)"Hidden" } |
| }; |
| |
| static named_value_t bssTypeStr[] = { |
| { BSS_INDEPENDENT, (PS8)"Independent" }, |
| { BSS_INFRASTRUCTURE, (PS8)"Infrastructure" }, |
| { BSS_ANY, (PS8)"Any" } |
| }; |
| |
| static named_value_t power_mode_val[] = { |
| { OS_POWER_MODE_AUTO, (PS8)"AUTO" }, |
| { OS_POWER_MODE_ACTIVE, (PS8)"ACTIVE" }, |
| { OS_POWER_MODE_SHORT_DOZE, (PS8)"SHORT_DOZE" }, |
| { OS_POWER_MODE_LONG_DOZE, (PS8)"LONG_DOZE" } |
| }; |
| |
| static named_value_t encrypt_type[] = { |
| { OS_ENCRYPTION_TYPE_NONE, (PS8)"None" }, |
| { OS_ENCRYPTION_TYPE_WEP, (PS8)"WEP" }, |
| { OS_ENCRYPTION_TYPE_TKIP, (PS8)"TKIP" }, |
| { OS_ENCRYPTION_TYPE_AES, (PS8)"AES" } |
| }; |
| |
| static named_value_t tKeepAliveTriggerTypes[] = { |
| { KEEP_ALIVE_TRIG_TYPE_NO_TX, (PS8)"When Idle" }, |
| { KEEP_ALIVE_TRIG_TYPE_PERIOD_ONLY, (PS8)"Always" } |
| }; |
| |
| #if 0 /* need to create debug logic for CLI */ |
| static named_value_t cli_level_type[] = { |
| { CU_MSG_DEBUG, (PS8)"CU_MSG_DEBUG" }, |
| { CU_MSG_INFO1, (PS8)"CU_MSG_INFO1" }, |
| { CU_MSG_WARNING, (PS8)"CU_MSG_WARNING" }, |
| { CU_MSG_ERROR, (PS8)"CU_MSG_ERROR" }, |
| { CU_MSG_INFO2, (PS8)"CU_MSG_INFO2" } |
| }; |
| #endif |
| |
| |
| static char *ConnState[] = { |
| "IDLE", |
| "SCANNING", |
| "CONNECTING", |
| "CONNECTED", |
| "DISCONNECT", |
| "IDLE" |
| }; |
| |
| |
| |
| static char ssidBuf[MAX_SSID_LEN +1]; |
| |
| /* local fucntions */ |
| /*******************/ |
| static S32 CuCmd_Str2MACAddr(PS8 str, PU8 mac) |
| { |
| S32 i; |
| |
| for( i=0; i<MAC_ADDR_LEN; i++ ) |
| { |
| mac[i] = (U8) os_strtoul(str, &str, 16); |
| str++; |
| } |
| return TRUE; |
| } |
| |
| /* used in get_bssid_list() */ |
| static U8 CuCmd_Freq2Chan(U32 freq) |
| { |
| U32 i; |
| |
| for(i=0; i<CHAN_FREQ_TABLE_SIZE; i++) |
| if(ChanFreq[i].freq == freq) |
| return ChanFreq[i].chan; |
| |
| return 0; |
| } |
| |
| /* Converts a single ASCII character to a hex value (i.e. '0'-'9' = 0-9, 'a'-'f' = a-f, 'A'-'F' = a-f) */ |
| static U8 CuCmd_atox(U8 c) |
| { |
| if (('0' <= c) && ('9' >= c)) |
| { |
| return c - '0'; |
| } |
| else if (('a' <= c) && ('f' >= c)) |
| { |
| return c - 'a' + 10; |
| } |
| else /* assuming input is valid */ |
| { |
| return c - 'A' + 10; |
| } |
| } |
| |
| /* converts an ASCII string to a buffer */ |
| static void CuCmd_atox_string (U8* srcString, U8* dstBuffer) |
| { |
| U32 uIndex, uLength; |
| |
| uLength = os_strlen ((PS8)srcString); |
| |
| /* clear the destination buffer */ |
| os_memset (dstBuffer, 0, (uLength / 2) + 1); |
| |
| for (uIndex = 0; uIndex < uLength; uIndex++) |
| { |
| if (0 == (uIndex % 2)) |
| { |
| dstBuffer[ uIndex / 2 ] |= (CuCmd_atox (srcString[ uIndex ]) << 4); |
| } |
| else |
| { |
| dstBuffer[ uIndex / 2 ] |= CuCmd_atox (srcString[ uIndex ]); |
| } |
| } |
| } |
| |
| static void CuCmd_xtoa_string (U8* srcBuffer, U32 srcBufferLength, U8* dstString) |
| { |
| U32 uIndex; |
| |
| for (uIndex = 0; uIndex < srcBufferLength; uIndex++) |
| { |
| os_sprintf ((PS8)&(dstString[ uIndex * 2 ]), (PS8)"%02x", srcBuffer[ uIndex ]); |
| } |
| } |
| |
| static VOID CuCmd_Init_Scan_Params(CuCmd_t* pCuCmd) |
| { |
| U8 i,j; |
| |
| /* init application scan default params */ |
| pCuCmd->appScanParams.desiredSsid.len = 0; |
| pCuCmd->appScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE; |
| pCuCmd->appScanParams.band = RADIO_BAND_2_4_GHZ; |
| pCuCmd->appScanParams.probeReqNumber = 3; |
| pCuCmd->appScanParams.probeRequestRate = RATE_MASK_UNSPECIFIED; /* Let the FW select */; |
| pCuCmd->appScanParams.numOfChannels = 14; |
| for ( i = 0; i < 14; i++ ) |
| { |
| for ( j = 0; j < 6; j++ ) |
| { |
| pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.bssId[ j ] = 0xff; |
| } |
| pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.earlyTerminationEvent = SCAN_ET_COND_DISABLE; |
| pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes = 0; |
| pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.maxChannelDwellTime = 60000; |
| pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.minChannelDwellTime = 30000; |
| pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.txPowerDbm = DEF_TX_POWER; |
| pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry.channel = i + 1; |
| } |
| |
| /* init periodic application scan params */ |
| pCuCmd->tPeriodicAppScanParams.uSsidNum = 0; |
| pCuCmd->tPeriodicAppScanParams.uSsidListFilterEnabled = 1; |
| pCuCmd->tPeriodicAppScanParams.uCycleNum = 0; /* forever */ |
| pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ 0 ] = 3; |
| for (i = 1; i < PERIODIC_SCAN_MAX_INTERVAL_NUM; i++) |
| { |
| pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ i ] = 30000; |
| } |
| pCuCmd->tPeriodicAppScanParams.iRssiThreshold = -80; |
| pCuCmd->tPeriodicAppScanParams.iSnrThreshold = 0; |
| pCuCmd->tPeriodicAppScanParams.uFrameCountReportThreshold = 1; |
| pCuCmd->tPeriodicAppScanParams.bTerminateOnReport = TRUE; |
| pCuCmd->tPeriodicAppScanParams.eBssType = BSS_ANY; |
| pCuCmd->tPeriodicAppScanParams.uProbeRequestNum = 3; |
| pCuCmd->tPeriodicAppScanParams.uChannelNum = 14; |
| for ( i = 0; i < 14; i++ ) |
| { |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eBand = RADIO_BAND_2_4_GHZ; |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uChannel = i + 1; |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eScanType = SCAN_TYPE_NORMAL_ACTIVE; |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMinDwellTimeMs = 5; |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMaxDwellTimeMs = 20; |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uTxPowerLevelDbm = DEF_TX_POWER; |
| } |
| |
| /* init default scan policy */ |
| pCuCmd->scanPolicy.normalScanInterval = 10000; |
| pCuCmd->scanPolicy.deterioratingScanInterval = 5000; |
| pCuCmd->scanPolicy.maxTrackFailures = 3; |
| pCuCmd->scanPolicy.BSSListSize = 4; |
| pCuCmd->scanPolicy.BSSNumberToStartDiscovery = 1; |
| pCuCmd->scanPolicy.numOfBands = 1; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].band = RADIO_BAND_2_4_GHZ; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].rxRSSIThreshold = -80; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].numOfChannles = 14; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].numOfChannlesForDiscovery = 3; |
| for ( i = 0; i < 14; i++ ) |
| { |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].channelList[ i ] = i + 1; |
| } |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.maxChannelDwellTime = 30000; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.minChannelDwellTime = 15000; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.bitrate = RATE_MASK_UNSPECIFIED; /* Let the FW select */ |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = DEF_TX_POWER; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.maxChannelDwellTime = 30000; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.minChannelDwellTime = 15000; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.bitrate = RATE_MASK_UNSPECIFIED; /* Let the FW select */; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = DEF_TX_POWER; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = 30000; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.minChannelDwellTime = 15000; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = RATE_MASK_UNSPECIFIED; /* Let the FW select */; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3; |
| pCuCmd->scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = DEF_TX_POWER; |
| } |
| |
| char* PrintSSID(OS_802_11_SSID* ssid) |
| { |
| /* It looks like it never happens. Anyway decided to check */ |
| if(ssid->SsidLength > MAX_SSID_LEN) |
| { |
| |
| os_error_printf(CU_MSG_ERROR, (PS8)"PrintSSID. ssid->SsidLength=%d exceeds the limit %d\n", |
| ssid->SsidLength, MAX_SSID_LEN); |
| /*WLAN_OS_REPORT(("PrintSSID. ssid->SsidLength=%d exceeds the limit %d\n", |
| ssid->SsidLength, MAX_SSID_LEN));*/ |
| ssid->SsidLength = MAX_SSID_LEN; |
| } |
| os_memcpy((PVOID)ssidBuf, (PVOID) ssid->Ssid, ssid->SsidLength); |
| ssidBuf[ssid->SsidLength] = '\0'; |
| return ssidBuf; |
| } |
| |
| static VOID CuCmd_PrintBssidList(OS_802_11_BSSID_LIST_EX* bssidList, S32 IsFullPrint, TMacAddr CurrentBssid) |
| { |
| U32 i; |
| S8 connectionTypeStr[50]; |
| POS_802_11_BSSID_EX pBssid = &bssidList->Bssid[0]; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"BssId List: Num=%u\n", bssidList->NumberOfItems); |
| os_error_printf(CU_MSG_INFO2, (PS8)" MAC Privacy Rssi Mode Channel SSID\n"); |
| for(i=0; i<bssidList->NumberOfItems; i++) |
| { |
| switch (pBssid->InfrastructureMode) |
| { |
| case os802_11IBSS: |
| os_strcpy (connectionTypeStr, (PS8)"Adhoc"); |
| break; |
| case os802_11Infrastructure: |
| os_strcpy (connectionTypeStr, (PS8)"Infra"); |
| break; |
| case os802_11AutoUnknown: |
| os_strcpy (connectionTypeStr, (PS8)"Auto"); |
| break; |
| default: |
| os_strcpy (connectionTypeStr, (PS8)" --- "); |
| break; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"%s%02x.%02x.%02x.%02x.%02x.%02x %3u %4d %s %6d %s\n", |
| (!os_memcmp(CurrentBssid, pBssid->MacAddress, MAC_ADDR_LEN))?"*":" ", |
| pBssid->MacAddress[0], |
| pBssid->MacAddress[1], |
| pBssid->MacAddress[2], |
| pBssid->MacAddress[3], |
| pBssid->MacAddress[4], |
| pBssid->MacAddress[5], |
| pBssid->Privacy, |
| (char)pBssid->Rssi | 0xffffff00, /* need the 0xffffff00 to get negative value display */ |
| connectionTypeStr, |
| CuCmd_Freq2Chan(pBssid->Configuration.Union.channel), |
| (pBssid->Ssid.Ssid[0] == '\0')?(PS8)"****":((PS8)pBssid->Ssid.Ssid) ); |
| |
| if (IsFullPrint) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)" BeaconInterval %d\n", pBssid->Configuration.BeaconPeriod); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Capabilities 0x%x\n", pBssid->Capabilities); |
| } |
| #ifdef _WINDOWS |
| pBssid = (POS_802_11_BSSID_EX)((S8*)pBssid + (pBssid->Length ? pBssid->Length : sizeof(OS_802_11_BSSID_EX))); |
| #else /*for Linux*/ |
| pBssid = &bssidList->Bssid[i+1]; |
| #endif |
| } |
| } |
| |
| static U8 CuCmd_Char2Hex( S8 c ) |
| { |
| if( c >= '0' && c <= '9' ) |
| return c - '0'; |
| else if( os_tolower(c) >= 'a' && os_tolower(c) <= 'f' ) |
| return (U8) (os_tolower(c) - 'a' + 0x0a); |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Char2Hex - invalid symbol '%c'\n", c ); |
| return ((U8)-1); |
| } |
| |
| static PS8 CuCmd_CreateRateStr(PS8 str, U8 rate) |
| { |
| if( rate == 0 ) |
| return os_strcpy(str,(PS8)"Auto (0)"); |
| |
| os_sprintf(str, (PS8)"%.3g Mbps", |
| RATE_2_MBPS(rate)); |
| |
| return str; |
| } |
| |
| static VOID CuCmd_PrintScanMethod(scan_Method_t* scanMethod) |
| { |
| S32 i; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Scan type: %s\n", scanType2Str[ scanMethod->scanType ].name); |
| switch (scanMethod->scanType) |
| { |
| case SCAN_TYPE_NORMAL_ACTIVE: |
| case SCAN_TYPE_NORMAL_PASSIVE: |
| os_error_printf(CU_MSG_INFO2, (PS8)"Max channel dwell time: %d, Min channel dwell time: %d\n", |
| scanMethod->method.basicMethodParams.maxChannelDwellTime, |
| scanMethod->method.basicMethodParams.minChannelDwellTime); |
| |
| CU_CMD_FIND_NAME_ARRAY(i, EtEvent2Str, scanMethod->method.basicMethodParams.earlyTerminationEvent); |
| os_error_printf(CU_MSG_INFO2 ,(PS8)"ET condition: %s, ET number of frames: %d\n", |
| EtEvent2Str[i].name, |
| scanMethod->method.basicMethodParams.ETMaxNumberOfApFrames); |
| |
| CU_CMD_FIND_NAME_ARRAY(i, rate2Str, scanMethod->method.basicMethodParams.probReqParams.bitrate); |
| os_error_printf(CU_MSG_INFO2 ,(PS8)"Probe request number: %d, probe request rate: %s, TX level: %d\n", |
| scanMethod->method.basicMethodParams.probReqParams.numOfProbeReqs, |
| rate2Str[i].name, |
| scanMethod->method.basicMethodParams.probReqParams.txPowerDbm); |
| break; |
| |
| case SCAN_TYPE_TRIGGERED_ACTIVE: |
| case SCAN_TYPE_TRIGGERED_PASSIVE: |
| os_error_printf(CU_MSG_INFO2, (PS8)"Triggering Tid: %d\n", scanMethod->method.TidTriggerdMethodParams.triggeringTid); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Max channel dwell time: %d, Min channel dwell time: %d\n", |
| scanMethod->method.basicMethodParams.maxChannelDwellTime, |
| scanMethod->method.basicMethodParams.minChannelDwellTime); |
| |
| CU_CMD_FIND_NAME_ARRAY(i, EtEvent2Str, scanMethod->method.basicMethodParams.earlyTerminationEvent); |
| os_error_printf(CU_MSG_INFO2, (PS8)"ET condition: %s, ET number of frames: %d\n", |
| EtEvent2Str[i].name, |
| scanMethod->method.basicMethodParams.ETMaxNumberOfApFrames); |
| |
| CU_CMD_FIND_NAME_ARRAY(i, rate2Str, scanMethod->method.basicMethodParams.probReqParams.bitrate); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Probe request number: %d, probe request rate: %s, TX level: %d\n", |
| scanMethod->method.basicMethodParams.probReqParams.numOfProbeReqs, |
| rate2Str[i].name, |
| scanMethod->method.basicMethodParams.probReqParams.txPowerDbm); |
| break; |
| |
| case SCAN_TYPE_SPS: |
| CU_CMD_FIND_NAME_ARRAY(i, EtEvent2Str, scanMethod->method.spsMethodParams.earlyTerminationEvent); |
| os_error_printf(CU_MSG_INFO2, (PS8)"ET condition: %s, ET number of frames: %d\n", |
| EtEvent2Str[i].name, |
| scanMethod->method.spsMethodParams.ETMaxNumberOfApFrames); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Scan duration: %d\n", scanMethod->method.spsMethodParams.scanDuration); |
| break; |
| |
| case SCAN_TYPE_NO_SCAN: |
| case SCAN_TYPE_PACTSIVE: |
| break; |
| } |
| } |
| |
| static VOID CuCmd_PrintScanBand(scan_bandPolicy_t* pBandPolicy) |
| { |
| S32 j; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nBand: %s\n", band2Str[ pBandPolicy->band ].name); |
| os_error_printf(CU_MSG_INFO2, (PS8)"RSSI Threshold: %d dBm\n", pBandPolicy->rxRSSIThreshold); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Number of channels for each discovery interval: %d\n", pBandPolicy->numOfChannlesForDiscovery); |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nTracking Method:\n"); |
| CuCmd_PrintScanMethod( &(pBandPolicy->trackingMethod) ); |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nDiscovery Method:\n"); |
| CuCmd_PrintScanMethod( &(pBandPolicy->discoveryMethod) ); |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nImmediate Scan Method:\n"); |
| CuCmd_PrintScanMethod( &(pBandPolicy->immediateScanMethod) ); |
| if ( pBandPolicy->numOfChannles > 0 ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nChannel list: "); |
| for ( j = 0; j < pBandPolicy->numOfChannles; j++ ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"%3d ", pBandPolicy->channelList[ j ]); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nNo channels defined.\n"); |
| } |
| } |
| |
| static U32 CuCmd_IsValueRate(U32 rate) |
| { |
| |
| switch (rate) |
| { |
| case 1: |
| case 2: |
| case 5: |
| case 6: |
| case 9: |
| case 11: |
| case 12: |
| case 18: |
| case 24: |
| case 36: |
| case 48: |
| case 54: |
| return (TRUE); |
| |
| default: |
| return (FALSE); |
| } |
| } |
| |
| static VOID CuCmd_ParseMaskString(PS8 pString, PU8 pBuffer, PU8 pLength) |
| { |
| S8 ch; |
| S32 iter = 0; |
| U8 val; |
| |
| while ((ch = pString[iter])) |
| { |
| val = (ch == '1' ? 1 : 0); |
| |
| if (iter % BIT_TO_BYTE_FACTOR) |
| pBuffer[iter / BIT_TO_BYTE_FACTOR] |= (val << (iter % BIT_TO_BYTE_FACTOR)); |
| else |
| pBuffer[iter / BIT_TO_BYTE_FACTOR] = val; |
| |
| ++iter; |
| } |
| |
| /* iter = 0 len = 0, iter = 1 len = 1, iter = 8 len = 1, and so on... */ |
| *pLength = (U8) (iter + BIT_TO_BYTE_FACTOR - 1) / BIT_TO_BYTE_FACTOR; |
| } |
| |
| static VOID CuCmd_ParsePatternString(PS8 pString, PU8 pBuffer, PU8 pLength) |
| { |
| S8 ch; |
| S32 iter = 0; |
| U8 val; |
| |
| while ((ch = pString[iter])) |
| { |
| val = ((ch >= '0' && ch <= '9') ? (ch - '0') : |
| (ch >= 'A' && ch <= 'F') ? (0xA + ch - 'A') : |
| (ch >= 'a' && ch <= 'f') ? (0xA + ch - 'a') : 0); |
| |
| /* even indexes go to the lower nibble, odd indexes push them to the */ |
| /* higher nibble and then go themselves to the lower nibble. */ |
| if (iter % 2) |
| pBuffer[iter / 2] = ((pBuffer[iter / 2] << (BIT_TO_BYTE_FACTOR / 2)) | val); |
| else |
| pBuffer[iter / 2] = val; |
| |
| ++iter; |
| } |
| |
| /* iter = 0 len = 0, iter = 1 len = 1, iter = 2 len = 1, and so on... */ |
| *pLength = (U8) (iter + 1) / 2; |
| } |
| |
| /* functions */ |
| /*************/ |
| THandle CuCmd_Create(const PS8 device_name, THandle hConsole, S32 BypassSupplicant, PS8 pSupplIfFile) |
| { |
| THandle hIpcSta; |
| |
| CuCmd_t* pCuCmd = (CuCmd_t*)os_MemoryCAlloc(sizeof(CuCmd_t), sizeof(U8)); |
| if(pCuCmd == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Create - cant allocate control block\n"); |
| return NULL; |
| } |
| |
| pCuCmd->isDeviceRunning = FALSE; |
| pCuCmd->hConsole = hConsole; |
| |
| pCuCmd->hCuCommon= CuCommon_Create(&hIpcSta, device_name); |
| if(pCuCmd->hCuCommon == NULL) |
| { |
| CuCmd_Destroy(pCuCmd); |
| return NULL; |
| } |
| |
| pCuCmd->hCuWext= CuOs_Create(hIpcSta); |
| if(pCuCmd->hCuWext == NULL) |
| { |
| CuCmd_Destroy(pCuCmd); |
| return NULL; |
| } |
| |
| pCuCmd->hIpcEvent = (THandle) IpcEvent_Create(); |
| if(pCuCmd->hIpcEvent == NULL) |
| { |
| CuCmd_Destroy(pCuCmd); |
| return NULL; |
| } |
| |
| if(BypassSupplicant) |
| { |
| /* specify that there is no supplicant */ |
| pCuCmd->hWpaCore = NULL; |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| S32 res; |
| |
| pCuCmd->hWpaCore = WpaCore_Create(&res, pSupplIfFile); |
| if((pCuCmd->hWpaCore == NULL) && (res != EOALERR_IPC_WPA_ERROR_CANT_CONNECT_TO_SUPPL)) |
| { |
| CuCmd_Destroy(pCuCmd); |
| return NULL; |
| } |
| |
| if(res == EOALERR_IPC_WPA_ERROR_CANT_CONNECT_TO_SUPPL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"******************************************************\n"); |
| os_error_printf(CU_MSG_ERROR, (PS8)"Connection to supplicant failed\n"); |
| os_error_printf(CU_MSG_ERROR, (PS8)"******************************************************\n"); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Connection established with supplicant\n"); |
| } |
| #endif |
| } |
| |
| CuCmd_Init_Scan_Params(pCuCmd); |
| |
| return pCuCmd; |
| } |
| |
| VOID CuCmd_Destroy(THandle hCuCmd) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if(pCuCmd->hCuCommon) |
| { |
| CuCommon_Destroy(pCuCmd->hCuCommon); |
| } |
| |
| if(pCuCmd->hCuWext) |
| { |
| CuOs_Destroy(pCuCmd->hCuWext); |
| } |
| |
| if(pCuCmd->hIpcEvent) |
| { |
| IpcEvent_Destroy(pCuCmd->hIpcEvent); |
| } |
| |
| #ifndef NO_WPA_SUPPL |
| if(pCuCmd->hWpaCore) |
| { |
| WpaCore_Destroy(pCuCmd->hWpaCore); |
| } |
| #endif |
| |
| os_MemoryFree(pCuCmd); |
| } |
| |
| S32 CuCmd_GetDeviceStatus(THandle hCuCmd) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 status; |
| |
| status = CuCommon_GetU32(pCuCmd->hCuCommon, DRIVER_STATUS_PARAM, &pCuCmd->isDeviceRunning); |
| |
| if ((status == OK) && pCuCmd->isDeviceRunning) |
| return OK; |
| |
| return ECUERR_CU_CMD_ERROR_DEVICE_NOT_LOADED; |
| } |
| |
| VOID CuCmd_StartDriver(THandle hCuCmd) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 uDummyBuf; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, DRIVER_START_PARAM, &uDummyBuf, sizeof(uDummyBuf))) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Failed to start driver!\n"); |
| } |
| } |
| |
| VOID CuCmd_StopDriver(THandle hCuCmd) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 uDummyBuf; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, DRIVER_STOP_PARAM, &uDummyBuf, sizeof(uDummyBuf))) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Failed to stop driver!\n"); |
| } |
| } |
| |
| #ifdef XCC_MODULE_INCLUDED |
| THandle CuCmd_GetCuCommonHandle(THandle hCuCmd) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| return pCuCmd->hCuCommon; |
| } |
| |
| THandle CuCmd_GetCuWpaHandle (THandle hCuCmd) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| return pCuCmd->hWpaCore; |
| |
| } |
| #endif |
| |
| VOID CuCmd_Show_Status(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| TMacAddr Mac; |
| OS_802_11_SSID ssid; |
| TMacAddr bssid; |
| U32 channel, threadid=0; |
| U32 status ; |
| |
| if(OK != CuCmd_GetDeviceStatus(hCuCmd)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Driver is stopped!\n"); |
| return; |
| } |
| |
| CuOs_GetDriverThreadId(pCuCmd->hCuWext, &threadid); |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, CTRL_DATA_MAC_ADDRESS, Mac, sizeof(TMacAddr))) return; |
| if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return; |
| if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid)) return; |
| if(OK != CuOs_GetCurrentChannel(pCuCmd->hCuWext, &channel)) return; |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, SME_CONNECTION_STATUS_PARAM, &status)) |
| os_error_printf(CU_MSG_INFO2, (PS8)"can't read connection status!\n"); |
| |
| if (threadid != 0) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Thread id: %u (0x%x)\n\n", threadid, threadid); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"==========================\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Status : %s\n",ConnState[status]); |
| 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]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"SSID : %s\n",(ssid.SsidLength)?PrintSSID(&ssid):"<empty>"); |
| 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]); |
| if(channel) |
| os_error_printf(CU_MSG_INFO2, (PS8)"Channel : %d\n",channel); |
| else |
| os_error_printf(CU_MSG_INFO2, (PS8)"Channel : <empty>\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"==========================\n"); |
| |
| } |
| |
| VOID CuCmd_BssidList(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 SizeOfBssiList=0; |
| OS_802_11_BSSID_LIST_EX* bssidList; |
| TMacAddr bssid; |
| |
| if(OK != CuCommon_Get_BssidList_Size(pCuCmd->hCuCommon, &SizeOfBssiList)) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant get Bssid list size\n"); |
| return; |
| } |
| |
| /* allocate the bssidList */ |
| bssidList = os_MemoryCAlloc(SizeOfBssiList, sizeof(U8)); |
| if(bssidList == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant allocate Bssid list\n"); |
| return; |
| } |
| |
| if(SizeOfBssiList == sizeof(U32)) |
| { |
| /* means that bssidList is empty*/ |
| bssidList->NumberOfItems = 0; |
| /* os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - size of list is %d, indicating empty list\n", |
| sizeof(U32)); */ |
| } |
| else |
| { |
| if (OK != CuOs_GetBssidList(pCuCmd->hCuWext, bssidList)) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant get Bssid list\n"); |
| os_MemoryFree(bssidList); |
| return; |
| } |
| } |
| |
| /* get currently connected bssid */ |
| if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid)) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant get current BSSID\n"); |
| os_MemoryFree(bssidList); |
| return; |
| } |
| |
| /* print the list to the terminal */ |
| CuCmd_PrintBssidList(bssidList, FALSE, bssid); |
| |
| /* free the bssidList */ |
| os_MemoryFree(bssidList); |
| |
| } |
| |
| VOID CuCmd_FullBssidList(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 SizeOfBssiList=0; |
| OS_802_11_BSSID_LIST_EX* bssidList; |
| TMacAddr bssid; |
| |
| if(OK != CuCommon_Get_BssidList_Size(pCuCmd->hCuCommon, &SizeOfBssiList)) return; |
| |
| /* allocate the bssidList */ |
| bssidList = os_MemoryCAlloc(SizeOfBssiList, sizeof(U8)); |
| if(bssidList == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_Bssid_List - cant allocate Bssid list\n"); |
| return; |
| } |
| |
| if(SizeOfBssiList == sizeof(U32)) |
| { |
| /* means that bssidList is empty*/ |
| bssidList->NumberOfItems = 0; |
| |
| } |
| else |
| { |
| if(OK != CuOs_GetBssidList(pCuCmd->hCuWext, bssidList) ) return; |
| } |
| |
| /* get currently connected bssid */ |
| if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid)) return; |
| |
| /* print the list to the terminal */ |
| CuCmd_PrintBssidList(bssidList, TRUE, bssid); |
| |
| /* free the bssidList */ |
| os_MemoryFree(bssidList); |
| } |
| |
| #if defined(CONFIG_WPS) && !defined(NO_WPA_SUPPL) |
| VOID CuCmd_StartEnrolleePIN(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot start Enrollee without connection to supplicant\n"); |
| return; |
| } |
| |
| WpaCore_StartWpsPIN(pCuCmd->hWpaCore); |
| os_error_printf(CU_MSG_INFO2, (PS8)"WPS in PIN mode started\n"); |
| } |
| |
| VOID CuCmd_StartEnrolleePBC(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot start Enrollee push button without connection to supplicant\n"); |
| return; |
| } |
| |
| WpaCore_StartWpsPBC(pCuCmd->hWpaCore); |
| os_error_printf(CU_MSG_INFO2, (PS8)"WPS in PBC mode started\n"); |
| } |
| |
| VOID CuCmd_StopEnrollee(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot Stop Enrollee without connection to supplicant\n"); |
| return; |
| } |
| |
| WpaCore_StopWps(pCuCmd->hWpaCore); |
| os_error_printf(CU_MSG_INFO2, (PS8)"WPS mode stopped\n"); |
| } |
| |
| VOID CuCmd_SetPin(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Cannot set PIN without connection to supplicant\n"); |
| return; |
| } |
| |
| WpaCore_SetPin(pCuCmd->hWpaCore, (PS8)parm[0].value); |
| os_error_printf(CU_MSG_INFO2, (PS8)"WPS PIN set %s\n", parm[0].value); |
| } |
| |
| #endif /* CONFIG_WPS */ |
| |
| VOID CuCmd_Connect(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TMacAddr bssid = { 0xff,0xff,0xff,0xff,0xff,0xff }; |
| OS_802_11_SSID ssid; |
| U32 BssType; |
| |
| switch (nParms) |
| { |
| case 0 : |
| /* |
| * No SSID & No BSSID are set - |
| * Use Any SSID & Any BSSID. |
| */ |
| ssid.SsidLength = 0; |
| ssid.Ssid[0] = 0; |
| break; |
| case 1: |
| /* |
| * SSID set & BSSID insn't set - |
| * Use CLI's SSID & Any BSSID. |
| */ |
| ssid.SsidLength = os_strlen( (PS8)parm[0].value); |
| os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[0].value, ssid.SsidLength); |
| ssid.Ssid[ssid.SsidLength] = '\0'; |
| break; |
| case 2: |
| /* |
| * Both SSID & BSSID are set - |
| * Use CLI's SSID & BSSID. |
| */ |
| if(!CuCmd_Str2MACAddr( (PS8)parm[1].value, bssid) ) |
| return; |
| ssid.SsidLength = os_strlen((PS8) parm[0].value); |
| os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[0].value, ssid.SsidLength); |
| ssid.Ssid[ssid.SsidLength] = '\0'; |
| break; |
| } |
| |
| if(pCuCmd->hWpaCore == NULL) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, &BssType)) return; |
| |
| if((BssType == os802_11IBSS/* Ad-Hoc */) && (ssid.SsidLength == 0)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"SSID string is needed due to fact that BSS Type set to Ad-Hoc.\n"); |
| return; |
| } |
| |
| if(OK != CuOs_Set_BSSID(pCuCmd->hCuWext, bssid ) ) return; |
| if(OK != CuOs_Set_ESSID(pCuCmd->hCuWext, &ssid) ) return; |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetBssType(pCuCmd->hWpaCore, &BssType)) return; |
| |
| if((BssType == os802_11IBSS/* Ad-Hoc */) && (ssid.SsidLength == 0)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"SSID string is needed due to fact BSS Type set to Ad-Hoc\n"); |
| return; |
| } |
| |
| WpaCore_SetSsid(pCuCmd->hWpaCore, &ssid, bssid); |
| #endif |
| } |
| } |
| |
| VOID CuCmd_Disassociate(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if(pCuCmd->hWpaCore == NULL) |
| { |
| OS_802_11_SSID ssid; |
| |
| ssid.SsidLength = MAX_SSID_LEN; |
| os_memset(ssid.Ssid, 0, MAX_SSID_LEN); |
| |
| CuOs_Set_ESSID(pCuCmd->hCuWext, &ssid); |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| WpaCore_Disassociate(pCuCmd->hWpaCore); |
| #endif |
| } |
| } |
| |
| VOID CuCmd_ModifySsid(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_SSID ssid; |
| TMacAddr bssid = { 0xff,0xff,0xff,0xff,0xff,0xff }; |
| |
| if( nParms == 0 ) |
| { |
| OS_802_11_SSID ssid; |
| if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"SSID: %s\n",(ssid.SsidLength)?(PS8)PrintSSID(&ssid):(PS8)"<empty>"); |
| } |
| else |
| { |
| /* Setting the new SSID, BRCS BSSID is set to clean pre-set BSSID */ |
| ssid.SsidLength = os_strlen((PS8) parm[0].value); |
| os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[0].value, ssid.SsidLength); |
| if(ssid.SsidLength < MAX_SSID_LEN) |
| { |
| ssid.Ssid[ssid.SsidLength] = 0; |
| } |
| |
| if(OK != CuOs_Set_BSSID(pCuCmd->hCuWext, bssid ) ) return; |
| if(OK != CuOs_Set_ESSID(pCuCmd->hCuWext, &ssid) ) return; |
| } |
| } |
| |
| VOID CuCmd_ModifyConnectMode(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 i; |
| |
| if( nParms == 0 ) |
| { |
| U32 uConnectMode; |
| |
| if(OK != CuCommon_GetU32 (pCuCmd->hCuCommon, SME_CONNECTION_MODE_PARAM, &uConnectMode)) return; |
| CU_CMD_FIND_NAME_ARRAY (i, Current_mode, uConnectMode); |
| os_error_printf (CU_MSG_INFO2, (PS8)"Current mode = %s\n", Current_mode[i].name); |
| print_available_values (Current_mode); |
| } |
| else |
| { |
| U32 uConnectMode = parm[0].value; |
| |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY (i, Current_mode, uConnectMode); |
| if(i == SIZE_ARR(Current_mode)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyConnectMode, Connect Mode %d is not defined!\n", uConnectMode); |
| print_available_values (Current_mode); |
| return; |
| } |
| else |
| { |
| CuCommon_SetU32(pCuCmd->hCuCommon, SME_CONNECTION_MODE_PARAM, uConnectMode); |
| } |
| } |
| } |
| |
| VOID CuCmd_ModifyChannel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms == 0 ) |
| { |
| U8 desiredChannel = 0; |
| U32 currentChannel = 0; |
| |
| |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, SITE_MGR_DESIRED_CHANNEL_PARAM, &desiredChannel)) return; |
| if(OK != CuOs_GetCurrentChannel(pCuCmd->hCuWext, ¤tChannel)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Channel=%d (desired: %d)\n",currentChannel,desiredChannel); |
| } |
| else |
| { |
| CuCommon_SetU32(pCuCmd->hCuCommon, SITE_MGR_DESIRED_CHANNEL_PARAM, parm[0].value); |
| } |
| } |
| |
| VOID CuCmd_GetTxRate(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms == 0) |
| { |
| U8 CurrentTxRate; |
| S8 CurrentTxRateStr[50]; |
| |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_CURRENT_RATES_GET, &CurrentTxRate)) return; |
| |
| CuCmd_CreateRateStr(CurrentTxRateStr, CurrentTxRate); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Rate: %s\n", CurrentTxRateStr); |
| } |
| } |
| |
| VOID CuCmd_ModifyBssType(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 BssType = 0; |
| S32 i; |
| |
| if( nParms == 0 ) |
| { |
| if(pCuCmd->hWpaCore == NULL) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, &BssType)) return; |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetBssType(pCuCmd->hWpaCore, &BssType)) return; |
| #endif |
| } |
| |
| CU_CMD_FIND_NAME_ARRAY(i, BSS_type, BssType); |
| if(i == SIZE_ARR(BSS_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Error getting the current BssType! BssType=0x%x\n",BssType); |
| return; |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Current mode = %s\n", BSS_type[i].name); |
| } |
| print_available_values(BSS_type); |
| } |
| else |
| { |
| BssType = parm[0].value; |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY(i, BSS_type, BssType); |
| if(i == SIZE_ARR(BSS_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyBssType, BssType %d is not defined!\n", BssType); |
| return; |
| } |
| if(pCuCmd->hWpaCore == NULL) |
| { |
| CuCommon_SetU32(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, BssType); |
| CuCommon_SetU32(pCuCmd->hCuCommon, SME_DESIRED_BSS_TYPE_PARAM, BssType); |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| WpaCore_SetBssType(pCuCmd->hWpaCore, BssType); |
| #endif |
| } |
| } |
| } |
| |
| VOID CuCmd_ModifyFragTh(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 FragTh; |
| |
| if( nParms == 0 ) |
| { |
| if(OK != CuOs_GetFragTh(pCuCmd->hCuWext, &FragTh)) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Frag. threshold = %d\n", FragTh); |
| } |
| else |
| { |
| FragTh = parm[0].value; |
| CuOs_SetFragTh(pCuCmd->hCuWext, FragTh); |
| } |
| } |
| |
| VOID CuCmd_ModifyRtsTh(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 RtsTh; |
| |
| if( nParms == 0 ) |
| { |
| if(OK != CuOs_GetRtsTh(pCuCmd->hCuWext, &RtsTh)) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"RTS threshold = %d\n", RtsTh); |
| } |
| else |
| { |
| RtsTh = parm[0].value; |
| CuOs_SetRtsTh(pCuCmd->hCuWext, RtsTh); |
| } |
| } |
| |
| VOID CuCmd_ModifyPreamble(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| EPreamble Preamble; |
| S32 i; |
| named_value_t preamble_type[] = { |
| { PREAMBLE_LONG, (PS8)"PREAMBLE_LONG" }, |
| { PREAMBLE_SHORT, (PS8)"PREAMBLE_SHORT" } |
| }; |
| |
| if(nParms) |
| { |
| Preamble = parm[0].value; |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY(i, preamble_type, Preamble); |
| if(i == SIZE_ARR(preamble_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyPreamble, Preamble %d is not defined!\n", Preamble); |
| return; |
| } |
| CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_SET, Preamble); |
| } |
| else |
| { |
| S32 PreambleData; |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_GET, (PU32)&PreambleData)) return; |
| Preamble = PreambleData; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Preamble = %d\n", Preamble); |
| print_available_values(preamble_type); |
| } |
| } |
| |
| VOID CuCmd_ModifyShortSlot(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| slotTime_e SlotTime; |
| S32 i; |
| named_value_t SlotTime_type[] = { |
| { PHY_SLOT_TIME_LONG, (PS8)"PHY_SLOT_TIME_LONG" }, |
| { PHY_SLOT_TIME_SHORT, (PS8)"PHY_SLOT_TIME_SHORT" } |
| }; |
| |
| if(nParms) |
| { |
| SlotTime = parm[0].value; |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY(i, SlotTime_type, SlotTime); |
| if(i == SIZE_ARR(SlotTime_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifyShortSlot, SlotTime %d is not defined!\n", SlotTime); |
| return; |
| } |
| CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_SHORT_SLOT_SET, SlotTime); |
| } |
| else |
| { |
| S32 SlotTimeData; |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_SHORT_SLOT_GET, (PU32)&SlotTimeData)) return; |
| SlotTime = SlotTimeData; |
| os_error_printf(CU_MSG_INFO2, (PS8)"SlotTime = %d\n", SlotTime); |
| print_available_values(SlotTime_type); |
| } |
| } |
| |
| |
| VOID CuCmd_RadioOnOff(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 on_off; |
| |
| if(nParms) |
| { |
| on_off = parm[0].value; |
| CuCommon_SetU32(pCuCmd->hCuCommon, SME_RADIO_ON_PARAM, on_off); |
| } |
| else |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, SME_RADIO_ON_PARAM, &on_off)) { |
| os_error_printf(CU_MSG_ERROR, (PS8)"CuCmd_RadioOnOff error, Cannot get radio state!\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_ERROR, (PS8)"Radio state = %s\n", on_off ? "ON" : "OFF"); |
| os_error_printf(CU_MSG_ERROR, (PS8)"Turn radio on/off. 0=OFF, 1=ON\n"); |
| } |
| } |
| |
| |
| VOID CuCmd_GetSelectedBssidInfo(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_SSID ssid; |
| TMacAddr bssid; |
| |
| if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return; |
| if(OK != CuOs_Get_BSSID(pCuCmd->hCuWext, bssid)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Selected BSSID Info:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"--------------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"SSID : %s\n",(ssid.SsidLength)?(PS8)PrintSSID(&ssid):(PS8)"<empty>"); |
| 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]); |
| } |
| |
| VOID CuCmd_GetRsiiLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S8 dRssi, bRssi; |
| |
| if(OK != CuCommon_GetRssi(pCuCmd->hCuCommon, &dRssi, &bRssi)) return; |
| /* need the 0xffffff00 to get negative value display */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"Current dataRSSI=%d beaconRssi=%d\n", dRssi?dRssi|0xffffff00:dRssi, bRssi?bRssi|0xffffff00:bRssi); |
| } |
| |
| VOID CuCmd_GetSnrRatio(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 dSnr, bSnr; |
| |
| if(OK != CuCommon_GetSnr(pCuCmd->hCuCommon, &dSnr, &bSnr)) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Current dataSNR=%d beaconSnr=%d\n", dSnr, bSnr); |
| } |
| |
| VOID CuCmd_ShowTxPowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| S32 txPowerLevel; |
| if(OK != CuOs_GetTxPowerLevel(pCuCmd->hCuWext, &txPowerLevel)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Tx Power level = %d\n", txPowerLevel); |
| } |
| |
| VOID CuCmd_ShowTxPowerTable(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TpowerLevelTable_t txPowerLevel; |
| S32 i, res; |
| |
| res = CuCommon_GetBuffer(pCuCmd->hCuCommon, REGULATORY_DOMAIN_TX_POWER_LEVEL_TABLE_PARAM, &txPowerLevel, sizeof(txPowerLevel)); |
| |
| if( !res ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Power level table (Dbm/10)\n"); |
| for (i = 0; i < NUMBER_OF_SUB_BANDS_E; i++) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"sub-band %i: %d %d %d %d\n", i, |
| txPowerLevel.uDbm[i][0], |
| txPowerLevel.uDbm[i][1], |
| txPowerLevel.uDbm[i][2], |
| txPowerLevel.uDbm[i][3]); |
| } |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Tx Power level table ERROR !!!\n"); |
| } |
| } |
| |
| VOID CuCmd_TxPowerDbm(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 txPowerLevelDbm = (U8)parm[0].value; |
| |
| if(nParms == 0) |
| { |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_TX_POWER_DBM_GET, (PU8)&txPowerLevelDbm)) return; |
| } |
| else |
| { |
| if (parm[0].value > MAX_TX_POWER) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Please use values between %d and %d\n", MIN_TX_POWER, MAX_TX_POWER); return; |
| } |
| else |
| { |
| if(OK != CuCommon_SetU8(pCuCmd->hCuCommon, TIWLN_802_11_TX_POWER_DBM_GET, (U8)txPowerLevelDbm)) return; |
| } |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Tx Power in DBM = %d\n", txPowerLevelDbm); |
| } |
| |
| VOID CuCmd_ModifyState_802_11d(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 Enabled_802_11d; |
| |
| if(nParms == 0) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_802_11D, &Enabled_802_11d)) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d enabled = %s\n", (Enabled_802_11d)?"TRUE":"FALSE"); |
| } |
| else |
| { |
| Enabled_802_11d = parm[0].value; |
| if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_ENABLE_DISABLE_802_11D, Enabled_802_11d)) |
| { |
| U32 Enabled_802_11h; |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_802_11H, &Enabled_802_11h)) return; |
| if(Enabled_802_11h && (!Enabled_802_11d)) |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d cannot be disabled while 802_11h is enabled!!\n" ); |
| |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d status is updated to = %s\n", (Enabled_802_11d)?"TRUE":"FALSE" ); |
| } |
| } |
| } |
| |
| VOID CuCmd_ModifyState_802_11h(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 Enabled_802_11h; |
| |
| if(nParms == 0) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_802_11H, &Enabled_802_11h)) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11h enabled = %s\n", (Enabled_802_11h)?"TRUE":"FALSE"); |
| } |
| else |
| { |
| Enabled_802_11h = parm[0].value; |
| if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_ENABLE_DISABLE_802_11H, Enabled_802_11h)) return; |
| if(Enabled_802_11h) |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11h enables automatically 802_11d!!\n" ); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11h status is updated to =%d\n", Enabled_802_11h ); |
| } |
| } |
| |
| VOID CuCmd_D_Country_2_4Ie(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms == 0 ) |
| { |
| U8 CountryString[DOT11_COUNTRY_STRING_LEN+1]; |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_COUNTRY_2_4, |
| CountryString, DOT11_COUNTRY_STRING_LEN+1)) return; |
| CountryString[DOT11_COUNTRY_STRING_LEN] = '\0'; |
| if (CountryString[0] == '\0') |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 2.4 GHz is not found\n"); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 2.4 GHz is %s \n", CountryString ); |
| } |
| } |
| else |
| { |
| country_t CountryWorld; |
| |
| CountryWorld.elementId = COUNTRY_IE_ID; |
| CountryWorld.len = 6; |
| os_memcpy( (PVOID)CountryWorld.countryIE.CountryString,(PVOID)"GB ", 3); |
| CountryWorld.countryIE.tripletChannels[0].firstChannelNumber = 1; |
| CountryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 23; |
| CountryWorld.countryIE.tripletChannels[0].numberOfChannels = 11; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_SET_COUNTRY_2_4, |
| &CountryWorld, sizeof(country_t))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Start Setting GB Country for 2.4 GHz\n"); |
| } |
| } |
| |
| |
| VOID CuCmd_D_Country_5Ie(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms == 0 ) |
| { |
| U8 CountryString[DOT11_COUNTRY_STRING_LEN+1]; |
| |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_GET_COUNTRY_5, |
| CountryString, DOT11_COUNTRY_STRING_LEN+1)) return; |
| |
| CountryString[DOT11_COUNTRY_STRING_LEN] = '\0'; |
| if (CountryString[0] == '\0') |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 5 GHz is not found\n"); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Country for 5 GHz is %s\n", CountryString ); |
| } |
| } |
| else |
| { |
| country_t CountryWorld; |
| |
| CountryWorld.elementId = COUNTRY_IE_ID; |
| CountryWorld.len = 6; |
| os_memcpy((PVOID) CountryWorld.countryIE.CountryString,(PVOID)"US ", 3); |
| CountryWorld.countryIE.tripletChannels[0].firstChannelNumber = 36; |
| CountryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 13; |
| CountryWorld.countryIE.tripletChannels[0].numberOfChannels = 8; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REG_DOMAIN_SET_COUNTRY_5, |
| &CountryWorld, sizeof(country_t))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"802_11d Start Setting US Country for 5 GHz\n"); |
| } |
| } |
| |
| VOID CuCmd_ModifyDfsRange(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U16 minDFS_channelNum; |
| U16 maxDFS_channelNum; |
| |
| if( nParms == 0 ) |
| { |
| if(OK != CuCommon_GetDfsChannels(pCuCmd->hCuCommon, &minDFS_channelNum, &maxDFS_channelNum)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"DFS min channel is %d, DFS max channel is %d\n", |
| minDFS_channelNum, maxDFS_channelNum); |
| } |
| else |
| { |
| minDFS_channelNum = (U16) parm[0].value; |
| maxDFS_channelNum = (U16) parm[1].value; |
| |
| if(OK != CuCommon_SetDfsChannels(pCuCmd->hCuCommon, minDFS_channelNum, maxDFS_channelNum)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting DFS min channel %d, DFS max channel %d\n", |
| minDFS_channelNum, maxDFS_channelNum); |
| } |
| } |
| |
| VOID CuCmd_SetBeaconFilterDesiredState(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms == 0 ) |
| { |
| print_available_values(BeaconFilter_use); |
| } |
| else |
| { |
| CuCommon_SetU8(pCuCmd->hCuCommon, TIWLN_802_11_BEACON_FILTER_DESIRED_STATE_SET, (U8)parm[0].value); |
| } |
| } |
| |
| VOID CuCmd_GetBeaconFilterDesiredState(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 beaconFilterDesiredState = 0; |
| |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_BEACON_FILTER_DESIRED_STATE_GET, &beaconFilterDesiredState)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Desired State is %s\n", (beaconFilterDesiredState == 0)?"FILTER INACTIVE":"FILTER ACTIVE" ); |
| } |
| |
| VOID CuCmd_ModifySupportedRates(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| rates_t SupportedRates; |
| S32 i; |
| |
| if( nParms == 0 ) |
| { |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SUPPORTED_RATES, |
| &SupportedRates, sizeof(rates_t))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)" Rates: "); |
| for( i=0; i < SupportedRates.len; i++ ) |
| { |
| os_error_printf(CU_MSG_INFO2, |
| (PS8)"%g Mbps(%u%s)%s", |
| /* patch in order to support NET_RATE_MCS7 values that equal to NET_RATE_1M_BASIC */ |
| (RATE_2_MBPS(SupportedRates.ratesString[i]) == 63.5) ? 65 : RATE_2_MBPS(SupportedRates.ratesString[i]), |
| /* patch in order to support NET_RATE_MCS7 values that equal to NET_RATE_1M_BASIC */ |
| (SupportedRates.ratesString[i] == 0x7f) ? 0x83 : SupportedRates.ratesString[i], |
| IS_BASIC_RATE(SupportedRates.ratesString[i]) ? " - basic" : "", |
| (i < SupportedRates.len-1) ? "," : "" ); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| } |
| else |
| { |
| PS8 buf = (PS8) parm[0].value; |
| PS8 end_p; |
| U32 val; |
| U32 MaxVal = ((1 << (sizeof(SupportedRates.ratesString[i]) * 8))-1); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"param: %s\n", buf ); |
| |
| for( i=0; *buf && i < DOT11_MAX_SUPPORTED_RATES; i++ ) |
| { |
| val = os_strtoul(buf, &end_p, 0); |
| if(val == 0) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifySupportedRates: invalid value - %s\n", buf ); |
| return; |
| } |
| if(val > MaxVal) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_ModifySupportedRates: out of range %d\n", val ); |
| return; |
| } |
| /* patch in order to support NET_RATE_MCS7 values that equal to NET_RATE_1M_BASIC */ |
| if (val == 0x83) |
| { |
| val = 0x7f; |
| } |
| SupportedRates.ratesString[i] = (U8)(val); |
| buf = end_p; |
| while( *buf==' ' || *buf == ',' ) buf++; |
| } |
| if(*buf) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"too many parameters. Max=%d\n", DOT11_MAX_SUPPORTED_RATES ); |
| return; |
| } |
| |
| SupportedRates.len = (U8) i; |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SUPPORTED_RATES, |
| &SupportedRates, sizeof(rates_t)); |
| } |
| } |
| |
| VOID CuCmd_SendHealthCheck(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, HEALTH_MONITOR_CHECK_DEVICE, TRUE)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Send health check...\n"); |
| } |
| |
| VOID CuCmd_EnableRxDataFilters(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_ENABLE_DISABLE_RX_DATA_FILTERS, TRUE)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Enabling Rx data filtering...\n"); |
| } |
| |
| VOID CuCmd_DisableRxDataFilters(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_ENABLE_DISABLE_RX_DATA_FILTERS, FALSE)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Disabling Rx data filtering...\n"); |
| } |
| |
| VOID CuCmd_AddRxDataFilter(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 res; |
| TRxDataFilterRequest request; |
| PS8 mask = (PS8) parm[1].value; |
| PS8 pattern = (PS8) parm[2].value; |
| |
| request.offset = (U8)parm[0].value; |
| CuCmd_ParseMaskString(mask, request.mask, &request.maskLength); |
| CuCmd_ParsePatternString(pattern, request.pattern, &request.patternLength); |
| |
| res = CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_ADD_RX_DATA_FILTER, |
| &request, sizeof(TRxDataFilterRequest)); |
| |
| if(res == OK) |
| os_error_printf(CU_MSG_INFO2, (PS8)"Filter added.\n"); |
| else |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddRxDataFilter - Couldn't add Rx data filter...\n"); |
| |
| } |
| |
| VOID CuCmd_RemoveRxDataFilter(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 res; |
| TRxDataFilterRequest request; |
| PS8 mask = (PS8) parm[1].value; |
| PS8 pattern = (PS8) parm[2].value; |
| |
| request.offset = (U8)parm[0].value; |
| CuCmd_ParseMaskString(mask, request.mask, &request.maskLength); |
| CuCmd_ParsePatternString(pattern, request.pattern, &request.patternLength); |
| |
| res = CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REMOVE_RX_DATA_FILTER, |
| &request, sizeof(TRxDataFilterRequest)); |
| |
| if(res == OK) |
| os_error_printf(CU_MSG_INFO2, (PS8)"Filter Removed.\n"); |
| else |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddRxDataFilter - Couldn't remove Rx data filter...\n"); |
| } |
| |
| VOID CuCmd_GetRxDataFiltersStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 UnmatchedPacketsCount; |
| U32 MatchedPacketsCount[4]; |
| |
| if (OK != CuCommon_GetRxDataFiltersStatistics(pCuCmd->hCuCommon, &UnmatchedPacketsCount, MatchedPacketsCount)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Rx data filtering statistics:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Unmatched packets: %u\n", UnmatchedPacketsCount); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #1: %u\n", MatchedPacketsCount[0]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #2: %u\n", MatchedPacketsCount[1]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #3: %u\n", MatchedPacketsCount[2]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Packets matching filter #4: %u\n", MatchedPacketsCount[3]); |
| } |
| |
| VOID CuCmd_ShowStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| U32 powerMode; |
| TMacAddr Mac; |
| OS_802_11_SSID ssid; |
| U8 desiredChannel; |
| S32 rtsTh; |
| S32 fragTh; |
| S32 txPowerLevel; |
| U8 bssType; |
| U32 desiredPreambleType; |
| TIWLN_COUNTERS driverCounters; |
| U32 AuthMode; |
| U8 CurrentTxRate; |
| S8 CurrentTxRateStr[20]; |
| U8 CurrentRxRate; |
| S8 CurrentRxRateStr[20]; |
| U32 DefaultKeyId; |
| U32 WepStatus; |
| S8 dRssi, bRssi; |
| #ifdef XCC_MODULE_INCLUDED |
| U32 XCCNetEap; |
| #endif |
| |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, CTRL_DATA_MAC_ADDRESS, |
| Mac, sizeof(TMacAddr))) return; |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET, &powerMode, sizeof(U32))) return; |
| if(OK != CuOs_Get_SSID(pCuCmd->hCuWext, &ssid)) return; |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, SITE_MGR_DESIRED_CHANNEL_PARAM, &desiredChannel)) return; |
| if(OK != CuOs_GetRtsTh(pCuCmd->hCuWext, &rtsTh)) return; |
| if(OK != CuOs_GetFragTh(pCuCmd->hCuWext, &fragTh)) return; |
| if(OK != CuOs_GetTxPowerLevel(pCuCmd->hCuWext, &txPowerLevel)) return; |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, &bssType)) return; |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_GET, &desiredPreambleType)) return; |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, SITE_MGR_TI_WLAN_COUNTERS_PARAM, &driverCounters, sizeof(TIWLN_COUNTERS))) return; |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_ENCRYPTION_STATUS_PARAM, &WepStatus)) return; |
| if(OK != CuCommon_GetRssi(pCuCmd->hCuCommon, &dRssi, &bRssi)) return; |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, &AuthMode)) return; |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_DEFAULT_KEY_ID, &DefaultKeyId)) return; |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetAuthMode(pCuCmd->hWpaCore, &AuthMode)) return; |
| if(OK != WpaCore_GetDefaultKey(pCuCmd->hWpaCore, &DefaultKeyId)) return; |
| #endif |
| } |
| |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_802_11_CURRENT_RATES_GET, &CurrentTxRate)) return; |
| CuCmd_CreateRateStr(CurrentTxRateStr, CurrentTxRate); |
| |
| if(OK != CuCommon_GetU8(pCuCmd->hCuCommon, TIWLN_GET_RX_DATA_RATE, &CurrentRxRate)) return; |
| CuCmd_CreateRateStr(CurrentRxRateStr, CurrentRxRate); |
| |
| #ifdef XCC_MODULE_INCLUDED |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_XCC_NETWORK_EAP, &XCCNetEap)) return; |
| #endif |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"******************\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Driver Statistics:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"******************\n"); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)" dot11CurrentTxRate : %s\n", CurrentTxRateStr); |
| os_error_printf(CU_MSG_INFO2, (PS8)" CurrentRxRate : %s\n", CurrentRxRateStr); |
| os_error_printf(CU_MSG_INFO2, (PS8)" dot11DesiredChannel : %d\n", desiredChannel); |
| 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]); |
| os_error_printf(CU_MSG_INFO2, (PS8)" dot11DesiredSSID : %s\n", ssid.Ssid); |
| os_error_printf(CU_MSG_INFO2, (PS8)" dot11BSSType : %d\n", bssType); |
| os_error_printf(CU_MSG_INFO2, (PS8)" AuthenticationMode : %d\n", AuthMode ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" bShortPreambleUsed : %d\n", desiredPreambleType ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" RTSThreshold : %d\n", rtsTh ); |
| os_error_printf(CU_MSG_INFO2, (PS8)"FragmentationThreshold : %d\n", fragTh ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" bDefaultWEPKeyDefined : %d\n", DefaultKeyId); |
| os_error_printf(CU_MSG_INFO2, (PS8)" WEPStatus : %d\n", WepStatus); |
| os_error_printf(CU_MSG_INFO2, (PS8)" TxPowerLevel : %d\n", txPowerLevel ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" PowerMode : %d\n", powerMode ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" dataRssi : %d\n", dRssi); |
| os_error_printf(CU_MSG_INFO2, (PS8)" beaconRssi : %d\n", bRssi); |
| /**/ |
| /* network layer statistics*/ |
| /**/ |
| os_error_printf(CU_MSG_INFO2, (PS8)" RecvOk : %d\n", driverCounters.RecvOk ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" RecvError : %d\n", driverCounters.RecvError ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" DirectedBytesRecv : %d\n", driverCounters.DirectedBytesRecv ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" DirectedFramesRecv : %d\n", driverCounters.DirectedFramesRecv ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" MulticastBytesRecv : %d\n", driverCounters.MulticastBytesRecv ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" MulticastFramesRecv : %d\n", driverCounters.MulticastFramesRecv ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" BroadcastBytesRecv : %d\n", driverCounters.BroadcastBytesRecv ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" BroadcastFramesRecv : %d\n", driverCounters.BroadcastFramesRecv ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" FcsErrors : %d\n", driverCounters.FcsErrors ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" BeaconsRecv : %d\n", driverCounters.BeaconsRecv ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" AssocRejects : %d\n", driverCounters.AssocRejects ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" AssocTimeouts : %d\n", driverCounters.AssocTimeouts ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" AuthRejects : %d\n", driverCounters.AuthRejects ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" AuthTimeouts : %d\n", driverCounters.AuthTimeouts ); |
| |
| /**/ |
| /* other statistics*/ |
| /**/ |
| #ifdef XCC_MODULE_INCLUDED |
| os_error_printf(CU_MSG_INFO2, (PS8)" dwSecuritySuit : %d\n", XCCNetEap); |
| #endif |
| } |
| |
| VOID CuCmd_ShowTxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TIWLN_TX_STATISTICS txCounters; |
| U32 TxQid; |
| U32 AverageDelay; |
| U32 AverageFWDelay; |
| U32 AverageMacDelay; |
| |
| if( nParms == 0 ) |
| { |
| if(OK != CuCommon_GetTxStatistics(pCuCmd->hCuCommon, &txCounters, 0)) return; |
| } |
| else |
| { |
| if(OK != CuCommon_GetTxStatistics(pCuCmd->hCuCommon, &txCounters, parm[0].value)) return; |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"*********************\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Tx Queues Statistics:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"*********************\n"); |
| |
| for (TxQid = 0; TxQid < MAX_NUM_OF_AC; TxQid++) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nTx Queue %d:\n", TxQid); |
| os_error_printf(CU_MSG_INFO2, (PS8)"===========\n"); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)" Total Good Frames : %d\n", txCounters.txCounters[TxQid].XmitOk ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Unicast Bytes : %d\n", txCounters.txCounters[TxQid].DirectedBytesXmit ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Unicast Frames : %d\n", txCounters.txCounters[TxQid].DirectedFramesXmit ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Multicast Bytes : %d\n", txCounters.txCounters[TxQid].MulticastBytesXmit ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Multicast Frames : %d\n", txCounters.txCounters[TxQid].MulticastFramesXmit ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Broadcast Bytes : %d\n", txCounters.txCounters[TxQid].BroadcastBytesXmit ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Broadcast Frames : %d\n", txCounters.txCounters[TxQid].BroadcastFramesXmit ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Retry Failures : %d\n", txCounters.txCounters[TxQid].RetryFailCounter ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Tx Timeout Failures : %d\n", txCounters.txCounters[TxQid].TxTimeoutCounter ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" No Link Failures : %d\n", txCounters.txCounters[TxQid].NoLinkCounter ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Other Failures : %d\n", txCounters.txCounters[TxQid].OtherFailCounter ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Max Consecutive Retry Failures : %d\n\n", txCounters.txCounters[TxQid].MaxConsecutiveRetryFail ); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)" Retry histogram:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" ----------------\n\n"); |
| 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); |
| os_error_printf(CU_MSG_INFO2, (PS8)" packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n", |
| txCounters.txCounters[TxQid].RetryHistogram[ 0 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 1 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 2 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 3 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 4 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 5 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 6 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 7 ]); |
| 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); |
| os_error_printf(CU_MSG_INFO2, (PS8)" packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n", |
| txCounters.txCounters[TxQid].RetryHistogram[ 8 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 9 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 10 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 11 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 12 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 13 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 14 ], |
| txCounters.txCounters[TxQid].RetryHistogram[ 15 ]); |
| |
| if (txCounters.txCounters[TxQid].NumPackets) |
| { |
| AverageDelay = txCounters.txCounters[TxQid].SumTotalDelayMs / txCounters.txCounters[TxQid].NumPackets; |
| AverageFWDelay = txCounters.txCounters[TxQid].SumFWDelayUs / txCounters.txCounters[TxQid].NumPackets; |
| AverageMacDelay = txCounters.txCounters[TxQid].SumMacDelayUs / txCounters.txCounters[TxQid].NumPackets; |
| } |
| else |
| { |
| AverageDelay = 0; |
| AverageFWDelay = 0; |
| AverageMacDelay = 0; |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)" Total Delay ms (average/sum) : %d / %d\n", AverageDelay, txCounters.txCounters[TxQid].SumTotalDelayMs); |
| os_error_printf(CU_MSG_INFO2, (PS8)" FW Delay us (average/sum) : %d / %d\n", AverageFWDelay, txCounters.txCounters[TxQid].SumFWDelayUs); |
| os_error_printf(CU_MSG_INFO2, (PS8)" MAC Delay us (average/sum) : %d / %d\n\n", AverageMacDelay, txCounters.txCounters[TxQid].SumMacDelayUs); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)" Delay Ranges [msec] : Num of packets\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" ------------------- : --------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 0 - 1 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_0_TO_1] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 1 - 10 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_1_TO_10] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 10 - 20 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_10_TO_20] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 20 - 40 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_20_TO_40] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 40 - 60 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_40_TO_60] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 60 - 80 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_60_TO_80] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 80 - 100 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_80_TO_100] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" 100 - 200 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_100_TO_200] ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Above 200 : %d\n", txCounters.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_ABOVE_200] ); |
| } |
| } |
| |
| VOID CuCmd_ShowAdvancedParams(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| U32 AuthMode; |
| TPowerMgr_PowerMode Mode; |
| S32 txPowerLevel; |
| #ifndef NO_WPA_SUPPL |
| OS_802_11_ENCRYPTION_TYPES EncryptionTypePairwise; |
| OS_802_11_ENCRYPTION_TYPES EncryptionTypeGroup; |
| #endif |
| S32 Preamble; |
| S32 FragTh; |
| S32 RtsTh; |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, &AuthMode)) return; |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetAuthMode(pCuCmd->hWpaCore, &AuthMode)) return; |
| #endif |
| } |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET, &Mode, sizeof(TPowerMgr_PowerMode))) return; |
| if(OK != CuOs_GetTxPowerLevel(pCuCmd->hCuWext, &txPowerLevel)) return; |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetEncryptionPairWise(pCuCmd->hWpaCore, &EncryptionTypePairwise)) return; |
| if(OK != WpaCore_GetEncryptionGroup(pCuCmd->hWpaCore, &EncryptionTypeGroup)) return; |
| #endif |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_SHORT_PREAMBLE_GET, (PU32)&Preamble)) return; |
| if(OK != CuOs_GetFragTh(pCuCmd->hCuWext, &FragTh)) return; |
| if(OK != CuOs_GetRtsTh(pCuCmd->hCuWext, &RtsTh)) return; |
| |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"********************\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Advanced Statistics:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"********************\n"); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)" Authentication : %u\n", AuthMode ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Power mode : %d\n", Mode.PowerMode ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Tx Power level : %d\n", txPowerLevel ); |
| #ifndef NO_WPA_SUPPL |
| os_error_printf(CU_MSG_INFO2, (PS8)" Encryption Pairwise: %u\n", EncryptionTypePairwise ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Encryption Group: %u\n", EncryptionTypeGroup ); |
| #endif |
| os_error_printf(CU_MSG_INFO2, (PS8)" Preamble : <%s>\n", (Preamble) ? "short" : "long"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Frag. threshold : %u\n", FragTh); |
| os_error_printf(CU_MSG_INFO2, (PS8)" RTS threshold : %u\n", RtsTh ); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Power mode: "); |
| print_available_values(power_mode_val); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Encryption type: "); |
| print_available_values(encrypt_type); |
| |
| } |
| |
| |
| VOID Cucmd_ShowPowerConsumptionStats(THandle hCuCmd,ConParm_t parm[],U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| ACXPowerConsumptionTimeStat_t tStatistics; |
| |
| os_memset( &tStatistics, 0, sizeof(ACXPowerConsumptionTimeStat_t) ); |
| |
| if (OK != CuCommon_GetPowerConsumptionStat(pCuCmd->hCuCommon,&tStatistics)) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - Failed to read power consumption statistic!\n"); |
| return; |
| } |
| |
| |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nPower Consumption Statistics:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"-----------------------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"activeTimeCnt:0x%x%x\n", tStatistics.awakeTimeCnt_Hi,tStatistics.awakeTimeCnt_Low ); |
| os_error_printf(CU_MSG_INFO2, (PS8)"elpTimeCnt: 0x%x%x\n", tStatistics.elpTimeCnt_Hi,tStatistics.elpTimeCnt_Low); |
| os_error_printf(CU_MSG_INFO2, (PS8)"powerDownTimeCnt: 0x%x%x\n", tStatistics.powerDownTimeCnt_Hi,tStatistics.powerDownTimeCnt_Low); |
| os_error_printf(CU_MSG_INFO2, (PS8)"ListenMode11BTimeCnt: 0x%x%x\n", tStatistics.ListenMode11BTimeCnt_Hi,tStatistics.ListenMode11BTimeCnt_Low); |
| os_error_printf(CU_MSG_INFO2, (PS8)"ListenModeOFDMTimeCnt: 0x%x%x\n", tStatistics.ListenModeOFDMTimeCnt_Hi,tStatistics.ListenModeOFDMTimeCnt_Low); |
| |
| } |
| |
| |
| |
| VOID CuCmd_ScanAppGlobalConfig(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if ( 0 == os_strcmp( (PS8)"<empty>", (PS8)parm[0].value) ) |
| { |
| pCuCmd->appScanParams.desiredSsid.len = 0; |
| pCuCmd->appScanParams.desiredSsid.str[ 0 ] = '\0'; |
| } |
| else |
| { |
| pCuCmd->appScanParams.desiredSsid.len = (U8) os_strlen((PS8)parm[0].value); |
| os_memcpy( (PVOID)&(pCuCmd->appScanParams.desiredSsid.str), (PVOID)parm[0].value, pCuCmd->appScanParams.desiredSsid.len ); |
| if(pCuCmd->appScanParams.desiredSsid.len < MAX_SSID_LEN) |
| { |
| pCuCmd->appScanParams.desiredSsid.str[pCuCmd->appScanParams.desiredSsid.len] = 0; |
| } |
| } |
| pCuCmd->appScanParams.scanType = parm[1].value; |
| pCuCmd->appScanParams.band = parm[2].value; |
| pCuCmd->appScanParams.probeReqNumber = (U8)parm[3].value; |
| pCuCmd->appScanParams.probeRequestRate = parm[4].value; |
| #ifdef TI_DBG |
| pCuCmd->appScanParams.Tid = (U8)parm[5].value; |
| pCuCmd->appScanParams.numOfChannels = (U8)parm[6].value; |
| #else |
| pCuCmd->appScanParams.Tid = 0; |
| pCuCmd->appScanParams.numOfChannels = (U8)parm[5].value; |
| #endif |
| } |
| |
| VOID CuCmd_ScanAppChannelConfig(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| scan_normalChannelEntry_t* pChannelEntry = |
| &(pCuCmd->appScanParams.channelEntry[ parm[0].value ].normalChannelEntry); |
| |
| if (parm[2].value < parm[3].value) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n"); |
| return; |
| } |
| |
| CuCmd_Str2MACAddr ((PS8)parm[1].value, pChannelEntry->bssId); |
| pChannelEntry->maxChannelDwellTime = parm[2].value; |
| pChannelEntry->minChannelDwellTime = parm[3].value; |
| pChannelEntry->earlyTerminationEvent = parm[4].value; |
| pChannelEntry->ETMaxNumOfAPframes = (U8)parm[5].value; |
| pChannelEntry->txPowerDbm = (U8)parm[6].value; |
| pChannelEntry->channel = (U8)parm[7].value; |
| } |
| |
| VOID CuCmd_ScanAppClear(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| os_memset( &pCuCmd->appScanParams, 0, sizeof(scan_Params_t) ); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Application scan parameters cleared.\n"); |
| } |
| |
| VOID CuCmd_ScanAppDisplay(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 i,j; |
| scan_normalChannelEntry_t* pNormalChannel; |
| |
| CU_CMD_FIND_NAME_ARRAY(j, rate2Str, pCuCmd->appScanParams.probeRequestRate); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Application Scan params:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"SSID: %s, Type: %s\n", |
| pCuCmd->appScanParams.desiredSsid.str, |
| scanType2Str[ pCuCmd->appScanParams.scanType ].name); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Band: %s, Number of probe req:%d, probe req. rate:%s\n", |
| band2Str[ pCuCmd->appScanParams.band ].name, |
| pCuCmd->appScanParams.probeReqNumber, |
| rate2Str[j].name); |
| #ifdef TI_DBG |
| os_error_printf(CU_MSG_INFO2, (PS8)"Tid :%d\n\n", pCuCmd->appScanParams.Tid); |
| #else |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| #endif |
| os_error_printf(CU_MSG_INFO2, (PS8)"Channel BSS ID Max time Min time ET event ET frame num Power\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------------------------------------------------------\n"); |
| for ( i = 0; i < pCuCmd->appScanParams.numOfChannels; i++ ) |
| { |
| pNormalChannel = &(pCuCmd->appScanParams.channelEntry[ i ].normalChannelEntry); |
| CU_CMD_FIND_NAME_ARRAY(j, EtEvent2Str, pNormalChannel->earlyTerminationEvent); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%2d %02x.%02x.%02x.%02x.%02x.%02x %7d %7d %s%3d %1d\n", |
| pNormalChannel->channel, |
| pNormalChannel->bssId[0],pNormalChannel->bssId[1],pNormalChannel->bssId[2],pNormalChannel->bssId[3],pNormalChannel->bssId[4],pNormalChannel->bssId[5], |
| pNormalChannel->maxChannelDwellTime, |
| pNormalChannel->minChannelDwellTime, |
| EtEvent2Str[j].name, |
| pNormalChannel->ETMaxNumOfAPframes, |
| pNormalChannel->txPowerDbm); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| } |
| |
| VOID CuCmd_ScanSetSra(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, SCAN_CNCN_SET_SRA, parm[0].value) ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8) "Failed setting Scan Result Aging"); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8) "Scan Result Aging set succesfully to %d seconds", parm[0].value); |
| } |
| |
| VOID CuCmd_ScanSetRssi(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (OK != CuCommon_SetU32(pCuCmd->hCuCommon, SCAN_CNCN_SET_RSSI, parm[0].value) ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8) "Failed setting Rssi filter threshold"); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8) "Rssi filter set succesfully to %d", parm[0].value); |
| } |
| |
| VOID CuCmd_StartScan(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_START_APP_SCAN_SET, |
| &pCuCmd->appScanParams, sizeof(scan_Params_t))) |
| { |
| return; |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Application scan started\n"); |
| |
| /* |
| * In order to have ability to set the application scan we are using application scan priver command |
| * exsample for using supplicant scan command below: |
| * #ifndef NO_WPA_SUPPL |
| * CuOs_Start_Scan(pCuCmd->hCuWext, &ssid); |
| * #endif |
| */ |
| } |
| |
| VOID CuCmd_WextStartScan(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_SSID ssid; |
| U8 scanType =0; |
| |
| switch (nParms) |
| { |
| case 0: |
| ssid.SsidLength = 0; |
| ssid.Ssid[0] = 0; |
| scanType = 0; |
| break; |
| case 1 : |
| /* |
| * No SSID & No BSSID are set - |
| * Use Any SSID & Any BSSID. |
| */ |
| ssid.SsidLength = 0; |
| ssid.Ssid[0] = 0; |
| scanType = (U8)parm[0].value; |
| break; |
| |
| case 2: |
| /* |
| * SSID set |
| * Use CLI's SSID & Any BSSID. |
| */ |
| ssid.SsidLength = os_strlen( (PS8)parm[1].value); |
| os_memcpy((PVOID)ssid.Ssid, (PVOID) parm[1].value, ssid.SsidLength); |
| ssid.Ssid[ssid.SsidLength] = '\0'; |
| scanType = (U8)parm[0].value; /* 0 - Active , 1 - Passive*/ |
| break; |
| |
| default: |
| os_error_printf(CU_MSG_ERROR, (PS8)"<Scan Type [0=Active, 1=Passive]> <ssid Name As optional>\n"); |
| return; |
| } |
| |
| |
| |
| #ifndef NO_WPA_SUPPL |
| CuOs_Start_Scan(pCuCmd->hCuWext, &ssid, scanType); |
| #else |
| os_error_printf(CU_MSG_INFO2, (PS8)"WEXT not build, Scan Not Started\n"); |
| #endif |
| |
| } |
| |
| VOID CuCmd_StopScan (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_STOP_APP_SCAN_SET, NULL, 0)) |
| { |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Application scan stopped\n"); |
| } |
| |
| VOID CuCmd_ConfigPeriodicScanGlobal (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| pCuCmd->tPeriodicAppScanParams.iRssiThreshold = (S8)parm[ 0 ].value; |
| pCuCmd->tPeriodicAppScanParams.iSnrThreshold = (S8)parm[ 1 ].value; |
| pCuCmd->tPeriodicAppScanParams.uFrameCountReportThreshold = parm[ 2 ].value; |
| pCuCmd->tPeriodicAppScanParams.bTerminateOnReport = parm[ 3 ].value; |
| pCuCmd->tPeriodicAppScanParams.eBssType = (ScanBssType_e )parm[ 4 ].value; |
| pCuCmd->tPeriodicAppScanParams.uProbeRequestNum = parm[ 5 ].value; |
| pCuCmd->tPeriodicAppScanParams.uCycleNum = parm[ 6 ].value; |
| pCuCmd->tPeriodicAppScanParams.uSsidNum = parm[ 7 ].value; |
| pCuCmd->tPeriodicAppScanParams.uSsidListFilterEnabled = (U8)(parm[ 8 ].value); |
| pCuCmd->tPeriodicAppScanParams.uChannelNum = parm[ 9 ].value; |
| } |
| |
| VOID CuCmd_ConfigPeriodicScanInterval (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ parm[ 0 ].value ] = parm[ 1 ].value; |
| } |
| |
| VOID CuCmd_ConfigurePeriodicScanSsid (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TSsid *pSsid = &pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ parm[ 0 ].value ].tSsid; |
| |
| pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ parm[ 0 ].value ].eVisability = parm[ 1 ].value; |
| pSsid->len = (U8)os_strlen ((PS8)parm[ 2 ].value); |
| os_memcpy ((PVOID)&(pSsid->str), |
| (PVOID)parm[ 2 ].value, |
| pSsid->len); |
| if(pSsid->len < MAX_SSID_LEN) |
| { |
| pSsid->str[pSsid->len] = 0; |
| } |
| } |
| |
| VOID CuCmd_ConfigurePeriodicScanChannel (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t *pCuCmd = (CuCmd_t*)hCuCmd; |
| TPeriodicChannelEntry *pChannelEnrty = &(pCuCmd->tPeriodicAppScanParams.tChannels[ parm[ 0 ].value ]); |
| |
| pChannelEnrty->eBand = parm[ 1 ].value; |
| pChannelEnrty->uChannel = parm[ 2 ].value; |
| pChannelEnrty->eScanType = parm[ 3 ].value; |
| pChannelEnrty->uMinDwellTimeMs = parm[ 4 ].value;; |
| pChannelEnrty->uMaxDwellTimeMs = parm[ 5 ].value; |
| pChannelEnrty->uTxPowerLevelDbm = parm[ 6 ].value; |
| } |
| |
| VOID CuCmd_ClearPeriodicScanConfiguration (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| os_memset (&(pCuCmd->tPeriodicAppScanParams), 0, sizeof (TPeriodicScanParams)); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Periodic application scan parameters cleared.\n"); |
| } |
| |
| VOID CuCmd_DisplayPeriodicScanConfiguration (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 i, j, k; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Application Periodic Scan parameters:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"RSSI Threshold: %d, SNR Threshold: %d, Report Threshold: %d Number of cycles: %d\n", |
| pCuCmd->tPeriodicAppScanParams.iRssiThreshold, pCuCmd->tPeriodicAppScanParams.iSnrThreshold, |
| pCuCmd->tPeriodicAppScanParams.uFrameCountReportThreshold, pCuCmd->tPeriodicAppScanParams.uCycleNum); |
| CU_CMD_FIND_NAME_ARRAY (i, booleanStr, pCuCmd->tPeriodicAppScanParams.bTerminateOnReport); |
| CU_CMD_FIND_NAME_ARRAY (j, bssTypeStr, pCuCmd->tPeriodicAppScanParams.eBssType); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Terminate on Report: %s, BSS type: %s, Probe Request Number: %d\n", |
| booleanStr[ i ].name, bssTypeStr[ j ].name, pCuCmd->tPeriodicAppScanParams.uProbeRequestNum); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"\nIntervals (msec):\n"); |
| for (i = 0; i < PERIODIC_SCAN_MAX_INTERVAL_NUM; i++) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"%d ", pCuCmd->tPeriodicAppScanParams.uCycleIntervalMsec[ i ]); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n\nSSIDs:\n"); |
| for (i = 0; i < (S32)pCuCmd->tPeriodicAppScanParams.uSsidNum; i++) |
| { |
| CU_CMD_FIND_NAME_ARRAY (j, ssidVisabilityStr, pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ i ].eVisability); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%s (%s), ", pCuCmd->tPeriodicAppScanParams.tDesiredSsid[ i ].tSsid.str, |
| ssidVisabilityStr[ j ].name); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n\nSSID List Filter Enabled: %d\n", pCuCmd->tPeriodicAppScanParams.uSsidListFilterEnabled ); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n\nChannels:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%-15s %-10s %-20s %-15s %-15s %-20s\n", |
| (PS8)"Band", (PS8)"Channel", (PS8)"Scan type", (PS8)"Min dwell time", (PS8)"Max dwell time", (PS8)"Power level (dBm*10)"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"----------------------------------------------------------------------------------------------------\n"); |
| for (i = 0; i < (S32)pCuCmd->tPeriodicAppScanParams.uChannelNum; i++) |
| { |
| CU_CMD_FIND_NAME_ARRAY (j, band2Str, pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eBand); |
| CU_CMD_FIND_NAME_ARRAY (k, scanType2Str, pCuCmd->tPeriodicAppScanParams.tChannels[ i ].eScanType); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%-15s %-10d %-20s %-15d %-15d %-20d\n", |
| band2Str[ j ].name, |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uChannel, |
| scanType2Str[ k ].name, |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMinDwellTimeMs, |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uMaxDwellTimeMs, |
| pCuCmd->tPeriodicAppScanParams.tChannels[ i ].uTxPowerLevelDbm); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| } |
| |
| VOID CuCmd_StartPeriodicScan (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, SCAN_CNCN_START_PERIODIC_SCAN, |
| &(pCuCmd->tPeriodicAppScanParams), sizeof(TPeriodicScanParams))) |
| { |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Periodic application scan started.\n"); |
| } |
| |
| VOID CuCmd_StopPeriodicScan (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, SCAN_CNCN_STOP_PERIODIC_SCAN, |
| NULL, 0)) |
| { |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Periodic application scan stopped.\n"); |
| } |
| |
| VOID CuCmd_ConfigScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| pCuCmd->scanPolicy.normalScanInterval = parm[ 0 ].value; |
| pCuCmd->scanPolicy.deterioratingScanInterval = parm[ 1 ].value; |
| pCuCmd->scanPolicy.maxTrackFailures = (U8)(parm[ 2 ].value); |
| pCuCmd->scanPolicy.BSSListSize = (U8)(parm[ 3 ].value); |
| pCuCmd->scanPolicy.BSSNumberToStartDiscovery = (U8)(parm[ 4 ].value); |
| pCuCmd->scanPolicy.numOfBands = (U8)(parm[ 5 ].value); |
| } |
| |
| VOID CuCmd_ConfigScanBand(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]); |
| |
| pBandPolicy->band = parm[ 1 ].value; |
| pBandPolicy->rxRSSIThreshold = (S8)(parm[ 2 ].value); |
| pBandPolicy->numOfChannlesForDiscovery = (U8)(parm[ 3 ].value); |
| pBandPolicy->numOfChannles = (U8)(parm[ 4 ].value); |
| } |
| |
| VOID CuCmd_ConfigScanBandChannel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]); |
| |
| pBandPolicy->channelList[ parm[ 1 ].value ] = (U8)(parm[ 2 ].value); |
| } |
| |
| VOID CuCmd_ConfigScanBandTrack(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]); |
| |
| if (parm[6].value < parm[7].value) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n"); |
| return; |
| } |
| |
| pBandPolicy->trackingMethod.scanType = parm[ 1 ].value; |
| |
| switch (pBandPolicy->trackingMethod.scanType) |
| { |
| case SCAN_TYPE_NORMAL_ACTIVE: |
| case SCAN_TYPE_NORMAL_PASSIVE: |
| pBandPolicy->trackingMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value); |
| pBandPolicy->trackingMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value); |
| pBandPolicy->trackingMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->trackingMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value; |
| pBandPolicy->trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value); |
| pBandPolicy->trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value); |
| break; |
| |
| case SCAN_TYPE_TRIGGERED_ACTIVE: |
| case SCAN_TYPE_TRIGGERED_PASSIVE: |
| /* Check if valid TID */ |
| if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255)) |
| { |
| 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)); |
| parm[ 4 ].value = 255; |
| } |
| |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.triggeringTid = (U8)(parm[ 4 ].value); |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value); |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value); |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value; |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value); |
| pBandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value); |
| break; |
| |
| case SCAN_TYPE_SPS: |
| pBandPolicy->trackingMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->trackingMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->trackingMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value; |
| break; |
| |
| default: |
| pBandPolicy->trackingMethod.scanType = SCAN_TYPE_NO_SCAN; |
| break; |
| } |
| } |
| |
| VOID CuCmd_ConfigScanBandDiscover(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]); |
| |
| if (parm[6].value < parm[7].value) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n"); |
| return; |
| } |
| |
| pBandPolicy->discoveryMethod.scanType = parm[ 1 ].value; |
| |
| switch (pBandPolicy->discoveryMethod.scanType) |
| { |
| case SCAN_TYPE_NORMAL_ACTIVE: |
| case SCAN_TYPE_NORMAL_PASSIVE: |
| pBandPolicy->discoveryMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value); |
| pBandPolicy->discoveryMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value); |
| pBandPolicy->discoveryMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value; |
| pBandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value); |
| pBandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value); |
| break; |
| |
| case SCAN_TYPE_TRIGGERED_ACTIVE: |
| case SCAN_TYPE_TRIGGERED_PASSIVE: |
| /* Check if valid TID */ |
| if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255)) |
| { |
| 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)); |
| parm[ 4 ].value = 255; |
| } |
| |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.triggeringTid = (U8)(parm[ 4 ].value); |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value); |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value); |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value; |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value); |
| pBandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value); |
| break; |
| |
| case SCAN_TYPE_SPS: |
| pBandPolicy->discoveryMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->discoveryMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->discoveryMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value; |
| break; |
| |
| default: |
| pBandPolicy->discoveryMethod.scanType = SCAN_TYPE_NO_SCAN; |
| break; |
| } |
| } |
| |
| VOID CuCmd_ConfigScanBandImmed(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| scan_bandPolicy_t* pBandPolicy = &(pCuCmd->scanPolicy.bandScanPolicy[ parm [ 0 ].value ]); |
| |
| if (parm[6].value < parm[7].value) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Max Dwell Time must be larger than or equal to Min Dwell Time...\n"); |
| return; |
| } |
| |
| pBandPolicy->immediateScanMethod.scanType = parm[ 1 ].value; |
| |
| switch (pBandPolicy->immediateScanMethod.scanType) |
| { |
| case SCAN_TYPE_NORMAL_ACTIVE: |
| case SCAN_TYPE_NORMAL_PASSIVE: |
| pBandPolicy->immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value); |
| pBandPolicy->immediateScanMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value); |
| pBandPolicy->immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value; |
| pBandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value); |
| pBandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value); |
| break; |
| |
| case SCAN_TYPE_TRIGGERED_ACTIVE: |
| case SCAN_TYPE_TRIGGERED_PASSIVE: |
| /* Check if valid TID */ |
| if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255)) |
| { |
| 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)); |
| parm[ 4 ].value = 255; |
| } |
| |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.triggeringTid = (U8)(parm[ 4 ].value); |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value); |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value); |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value; |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (U8)(parm[ 8 ].value); |
| pBandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (U8)(parm[ 10 ].value); |
| break; |
| |
| case SCAN_TYPE_SPS: |
| pBandPolicy->immediateScanMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value; |
| pBandPolicy->immediateScanMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (U8)(parm[ 3 ].value); |
| pBandPolicy->immediateScanMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value; |
| break; |
| |
| default: |
| pBandPolicy->immediateScanMethod.scanType = SCAN_TYPE_NO_SCAN; |
| break; |
| } |
| } |
| |
| VOID CuCmd_DisplayScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 i; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Scan Policy:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Normal scan interval: %d, deteriorating scan interval: %d\n", |
| pCuCmd->scanPolicy.normalScanInterval, pCuCmd->scanPolicy.deterioratingScanInterval); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Max track attempt failures: %d\n", pCuCmd->scanPolicy.maxTrackFailures); |
| os_error_printf(CU_MSG_INFO2, (PS8)"BSS list size: %d, number of BSSes to start discovery: %d\n", |
| pCuCmd->scanPolicy.BSSListSize, pCuCmd->scanPolicy.BSSNumberToStartDiscovery); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Number of configured bands: %d\n", pCuCmd->scanPolicy.numOfBands); |
| for ( i = 0; i < pCuCmd->scanPolicy.numOfBands; i++ ) |
| { |
| CuCmd_PrintScanBand(&(pCuCmd->scanPolicy.bandScanPolicy[ i ])); |
| } |
| } |
| |
| VOID CuCmd_ClearScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| os_memset( &pCuCmd->scanPolicy, 0, sizeof(scan_Policy_t) ); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Scan policy cleared.\n"); |
| } |
| |
| VOID CuCmd_SetScanPolicy(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SCAN_POLICY_PARAM_SET, |
| &pCuCmd->scanPolicy, sizeof(scan_Policy_t))) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Scan policy stored.\n"); |
| } |
| |
| VOID CuCmd_GetScanBssList(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| bssList_t list; |
| S32 i; |
| |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SCAN_BSS_LIST_GET, |
| &list, sizeof(bssList_t))) return; |
| |
| /* os_error_printf list */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"BSS List:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%-17s %-7s %-6s %-4s %-10s\n", (PS8)"BSSID", (PS8)"Band", (PS8)"Channel", (PS8)"RSSI", (PS8)"Neighbor?"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"-----------------------------------------------------\n"); |
| for ( i = 0; i < list.numOfEntries; i++ ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"%02x.%02x.%02x.%02x.%02x.%02x %s %-7d %-4d %s\n", |
| 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], |
| band2Str[ list.BSSList[ i ].band ].name, |
| list.BSSList[ i ].channel, list.BSSList[ i ].RSSI, |
| (TRUE == list.BSSList[ i ].bNeighborAP ? (PS8)"Yes" : (PS8)"No") ); |
| } |
| } |
| |
| VOID CuCmd_RoamingEnable(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t))) return; |
| roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_ENABLED; |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Roaming is enabled \n"); |
| } |
| |
| VOID CuCmd_RoamingDisable(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_DISABLED; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Roaming is disabled \n"); |
| } |
| |
| VOID CuCmd_RoamingLowPassFilter(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt = (U16) parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Time in sec to wait before low quality Roaming Triggers, \n lowPassFilterRoamingAttempt = %d sec\n", |
| roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt); |
| } |
| |
| VOID CuCmd_RoamingQualityIndicator(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold = (S8) parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Quality indicator (RSSI) to be used when comparing AP List matching quality, \n apQualityThreshold = %d \n", |
| (roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold)); |
| } |
| |
| VOID CuCmd_RoamingDataRetryThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold = (S8) parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"dataRetryThreshold = %d \n", |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold); |
| |
| } |
| VOID CuCmd_RoamingNumExpectedTbttForBSSLoss(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss = (S8) parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Number of expected TBTTs for BSS Loss event, \n numExpectedTbttForBSSLoss = %d \n", |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss); |
| |
| } |
| VOID CuCmd_RoamingTxRateThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold = (S8 )parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"txRateThreshold = %d \n", |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold); |
| |
| } |
| |
| VOID CuCmd_RoamingLowRssiThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold = (S8) parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"lowRssiThreshold = %d \n", |
| (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold)); |
| |
| } |
| |
| VOID CuCmd_RoamingLowSnrThreshold(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold = (S8)parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"lowSnrThreshold = %d \n", roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold); |
| } |
| |
| VOID CuCmd_RoamingLowQualityForBackgroungScanCondition(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition = (S8) parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Indicator used to increase the background scan period when quality is low, \n lowQualityForBackgroungScanCondition = %d \n", |
| (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition)); |
| |
| } |
| |
| VOID CuCmd_RoamingNormalQualityForBackgroungScanCondition(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| if( nParms != 0 ) |
| { |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition = (S8) parm[0].value; |
| if(OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Indicator used to reduce the background scan period when quality is normal, \n normalQualityForBackgroungScanCondition = %d \n", |
| (roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition)); |
| |
| } |
| |
| VOID CuCmd_RoamingGetConfParams(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| roamingMngrConfigParams_t roamingMngrConfigParams; |
| |
| if(OK != CuCommon_GetBuffer (pCuCmd->hCuCommon, ROAMING_MNGR_APPLICATION_CONFIGURATION, |
| &roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t)) ) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Roaming is: %s \n", roamingMngrConfigParams.roamingMngrConfig.enableDisable ? "Enabled" : "Disabled\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" lowPassFilterRoamingAttempt = %d sec,\n apQualityThreshold = %d\n", |
| roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt, |
| roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold); |
| os_error_printf(CU_MSG_INFO2, (PS8)" Roaming Triggers' thresholds are: \n"); |
| 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", |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold, |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition, |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold, |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold, |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition, |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss, |
| roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold); |
| } |
| |
| VOID CuCmd_CurrBssUserDefinedTrigger(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t *pCuCmd = (CuCmd_t*)hCuCmd; |
| TUserDefinedQualityTrigger userTrigger; |
| |
| if (nParms == 0) |
| return; |
| |
| userTrigger.uIndex = (U8)parm[0].value; |
| userTrigger.iThreshold = (U16)parm[1].value; |
| userTrigger.uPacing = (U16)parm[2].value; |
| userTrigger.uMetric = (U8)parm[3].value; |
| userTrigger.uType = (U8)parm[4].value; |
| userTrigger.uDirection = (U8)parm[5].value; |
| userTrigger.uHystersis = (U8)parm[6].value; |
| userTrigger.uEnable = (U8)parm[7].value; |
| |
| userTrigger.uClientID = 0; /* '0' means that external application with no clientId has registered for the event */ |
| |
| if (OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, CURR_BSS_REGISTER_LINK_QUALITY_EVENT_PARAM, |
| &userTrigger, sizeof(TUserDefinedQualityTrigger)) ) |
| return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RoamingUserDefinedTrigger: \n \ |
| index = %d, \n \ |
| threshold = %d, \n \ |
| pacing = %d, \n \ |
| metric = %d, \n \ |
| type = %d, \n \ |
| direction = %d, \n \ |
| hystersis = %d, \n \ |
| enable = %d \n", |
| userTrigger.uIndex, |
| userTrigger.iThreshold, |
| userTrigger.uPacing, |
| userTrigger.uMetric, |
| userTrigger.uType, |
| userTrigger.uDirection, |
| userTrigger.uHystersis, |
| userTrigger.uEnable); |
| } |
| |
| VOID CuCmd_AddTspec(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_QOS_TSPEC_PARAMS TspecParams; |
| |
| TspecParams.uUserPriority = parm[0].value; |
| TspecParams.uNominalMSDUsize = parm[1].value; |
| TspecParams.uMeanDataRate = parm[2].value; |
| TspecParams.uMinimumPHYRate = parm[3].value * 1000 * 1000; |
| TspecParams.uSurplusBandwidthAllowance = parm[4].value << 13; |
| TspecParams.uAPSDFlag = parm[5].value; |
| TspecParams.uMinimumServiceInterval = parm[6].value; |
| TspecParams.uMaximumServiceInterval = parm[7].value; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_ADD_TSPEC, |
| &TspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS))) return; |
| |
| 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", |
| parm[0].value, |
| parm[1].value, |
| parm[2].value, |
| parm[3].value, |
| parm[4].value, |
| parm[5].value, |
| parm[6].value, |
| parm[7].value); |
| |
| } |
| |
| VOID CuCmd_GetTspec(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_QOS_TSPEC_PARAMS TspecParams; |
| |
| TspecParams.uUserPriority = parm[0].value; |
| |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_TSPEC_PARAMS, |
| &TspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS))) return; |
| |
| 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", |
| TspecParams.uUserPriority, |
| TspecParams.uNominalMSDUsize, |
| TspecParams.uMeanDataRate, |
| TspecParams.uMinimumPHYRate, |
| TspecParams.uSurplusBandwidthAllowance, |
| TspecParams.uAPSDFlag, |
| TspecParams.uMinimumServiceInterval, |
| TspecParams.uMaximumServiceInterval, |
| TspecParams.uMediumTime); |
| } |
| |
| VOID CuCmd_DeleteTspec(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_QOS_DELETE_TSPEC_PARAMS TspecParams; |
| |
| TspecParams.uUserPriority = parm[0].value; |
| TspecParams.uReasonCode = parm[1].value; |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_DELETE_TSPEC, |
| &TspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"TSPEC Delete request sent to driver...\n uUserPriority = %d\n uReasonCode = %d\n", |
| TspecParams.uUserPriority, |
| TspecParams.uReasonCode); |
| } |
| |
| VOID CuCmd_GetApQosParams(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_AC_QOS_PARAMS AcQosParams; |
| S32 i = 0; |
| |
| /* test if we can get the AC QOS Params */ |
| AcQosParams.uAC = i; |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_AP_QOS_PARAMS, |
| &AcQosParams, sizeof(AcQosParams))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"AP QOS Parameters:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"+----+-------------+----------+-----------+-----------+-----------+\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"| AC | AdmCtrlFlag | AIFS | CwMin | CwMax | TXOPLimit |\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"+----+-------------+----------+-----------+-----------+-----------+\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"| %2d | %11d | %8d | %9d | %9d | %9d |\n", |
| i, |
| AcQosParams.uAssocAdmissionCtrlFlag, |
| AcQosParams.uAIFS, |
| AcQosParams.uCwMin, |
| AcQosParams.uCwMax, |
| AcQosParams.uTXOPLimit); |
| |
| for (i=1; i<4; i++) |
| { |
| AcQosParams.uAC = i; |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_AP_QOS_PARAMS, |
| &AcQosParams, sizeof(AcQosParams))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"| %2d | %11d | %8d | %9d | %9d | %9d |\n", |
| i, |
| AcQosParams.uAssocAdmissionCtrlFlag, |
| AcQosParams.uAIFS, |
| AcQosParams.uCwMin, |
| AcQosParams.uCwMax, |
| AcQosParams.uTXOPLimit); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"+----+-------------+----------+-----------+-----------+-----------+\n"); |
| } |
| |
| VOID CuCmd_GetPsRxStreamingParams(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TPsRxStreaming tPsRxStreaming; |
| S32 i = 0; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"PS Rx Streaming Parameters:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"+-----+--------------+------------+---------+\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"| TID | StreamPeriod | uTxTimeout | Enabled |\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"+-----+--------------+------------+---------+\n"); |
| |
| for (i=0; i<8; i++) |
| { |
| tPsRxStreaming.uTid = i; |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, QOS_MNGR_PS_RX_STREAMING, |
| &tPsRxStreaming, sizeof(TPsRxStreaming))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"| %3d | %12d | %10d | %7d |\n", |
| tPsRxStreaming.uTid, |
| tPsRxStreaming.uStreamPeriod, |
| tPsRxStreaming.uTxTimeout, |
| tPsRxStreaming.bEnabled); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"+-----+--------------+------------+---------+\n"); |
| } |
| |
| VOID CuCmd_GetApQosCapabilities(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| OS_802_11_AP_QOS_CAPABILITIES_PARAMS ApQosCapabiltiesParams; |
| |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_AP_QOS_CAPABILITIES, |
| &ApQosCapabiltiesParams, sizeof(OS_802_11_AP_QOS_CAPABILITIES_PARAMS))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"AP Qos Capabilities:\n QOSFlag = %d\n APSDFlag = %d\n", |
| ApQosCapabiltiesParams.uQOSFlag, |
| ApQosCapabiltiesParams.uAPSDFlag); |
| |
| } |
| |
| VOID CuCmd_GetAcStatus(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_AC_UPSD_STATUS_PARAMS AcStatusParams; |
| |
| AcStatusParams.uAC = parm[0].value; |
| |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_CURRENT_AC_STATUS, |
| &AcStatusParams, sizeof(OS_802_11_AC_UPSD_STATUS_PARAMS))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"AC %d Status:\n", AcStatusParams.uAC); |
| os_error_printf(CU_MSG_INFO2, (PS8)"PS Scheme = %d (0=LEGACY, 1=UPSD)\n", AcStatusParams.uCurrentUAPSDStatus); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Admission Status = %d (0=NOT_ADMITTED, 1=WAIT_ADMISSION, 2=ADMITTED)\n", AcStatusParams.pCurrentAdmissionStatus); |
| } |
| |
| VOID CuCmd_ModifyMediumUsageTh(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_THRESHOLD_CROSS_PARAMS ThCrossParams; |
| |
| if (nParms == 3) /* If user supplied 3 parameters - this is a SET operation */ |
| { |
| ThCrossParams.uAC = parm[0].value; |
| ThCrossParams.uHighThreshold = parm[1].value; |
| ThCrossParams.uLowThreshold = parm[2].value; |
| |
| if (ThCrossParams.uLowThreshold > ThCrossParams.uHighThreshold) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Low threshold cannot be higher than the High threshold...Aborting...\n"); |
| return; |
| } |
| |
| if(OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_MEDIUM_USAGE_THRESHOLD, |
| &ThCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Medium usage threshold for AC %d has been set to:\n LowThreshold = %d\n HighThreshold = %d\n", |
| ThCrossParams.uAC, |
| ThCrossParams.uLowThreshold, |
| ThCrossParams.uHighThreshold); |
| } |
| else if (nParms == 1) /* Only 1 parameter means a GET operation */ |
| { |
| ThCrossParams.uAC = parm[0].value; |
| ThCrossParams.uLowThreshold = 0; |
| ThCrossParams.uHighThreshold = 0; |
| |
| if(OK != CuCommon_GetSetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_MEDIUM_USAGE_THRESHOLD, |
| &ThCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Medium usage threshold for AC %d:\n LowThreshold = %d\n HighThreshold = %d\n", |
| ThCrossParams.uAC, |
| ThCrossParams.uLowThreshold, |
| ThCrossParams.uHighThreshold); |
| } |
| } |
| |
| |
| VOID CuCmd_GetDesiredPsMode(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_QOS_DESIRED_PS_MODE DesiredPsMode; |
| |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_DESIRED_PS_MODE, |
| &DesiredPsMode, sizeof(OS_802_11_QOS_DESIRED_PS_MODE))) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Desired PS Mode (0=PS_POLL, 1=UPSD, 2=PS_NONE):\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"===============================================\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" +-----------+------+\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" | AC | Mode |\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" +-----------+------+\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)" | General | %d |\n", DesiredPsMode.uDesiredPsMode); |
| os_error_printf(CU_MSG_INFO2, (PS8)" | BE_AC | %d |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BE]); |
| os_error_printf(CU_MSG_INFO2, (PS8)" | BK_AC | %d |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BK]); |
| os_error_printf(CU_MSG_INFO2, (PS8)" | VI_AC | %d |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VI]); |
| os_error_printf(CU_MSG_INFO2, (PS8)" | VO_AC | %d |\n", DesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VO]); |
| os_error_printf(CU_MSG_INFO2, (PS8)" +-----------+------+\n"); |
| } |
| |
| |
| VOID CuCmd_InsertClsfrEntry(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| clsfr_tableEntry_t newUserTableEntry; |
| S32 i; |
| |
| if (nParms >=2) |
| newUserTableEntry.DTag = (U8) parm[1].value; |
| |
| switch(parm[0].value) |
| { |
| case D_TAG_CLSFR: |
| os_error_printf(CU_MSG_INFO2, (PS8)"Cannot insert D_TAG classifier entry!\n"); |
| return; |
| case DSCP_CLSFR: |
| if (nParms != 3) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n"); |
| return; |
| } |
| newUserTableEntry.Dscp.CodePoint = (U8) parm[2].value; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Inserting new DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint); |
| break; |
| case PORT_CLSFR: |
| if (nParms != 3) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters(too many?)\n"); |
| return; |
| } |
| newUserTableEntry.Dscp.DstPortNum = (U16) parm[2].value; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Inserting new PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum); |
| break; |
| case IPPORT_CLSFR: |
| if (nParms != 7) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters\n"); |
| return; |
| } |
| newUserTableEntry.Dscp.DstIPPort.DstPortNum = (U16) parm[2].value; |
| newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0; |
| for(i=0; i<4; i++) |
| { |
| newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Inserting new IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n", |
| newUserTableEntry.DTag, |
| newUserTableEntry.Dscp.DstIPPort.DstPortNum, |
| (S32)parm[3].value,(S32)parm[4].value,(S32)parm[5].value,(S32)parm[6].value); |
| break; |
| default: |
| os_error_printf(CU_MSG_INFO2, (PS8)"Unknown Classifier Type - Command aborted!\n"); |
| return; |
| } |
| |
| if(CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_CONFIG_TX_CLASS, |
| &newUserTableEntry, sizeof(clsfr_tableEntry_t))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Failed to insert new classifier entry...\n"); |
| } |
| } |
| |
| VOID CuCmd_RemoveClsfrEntry(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| clsfr_tableEntry_t newUserTableEntry; |
| S32 i; |
| |
| if (nParms >=2) |
| newUserTableEntry.DTag = (U8) parm[1].value; |
| |
| switch(parm[0].value) |
| { |
| case D_TAG_CLSFR: |
| os_error_printf(CU_MSG_INFO2, (PS8)"Cannot remove D_TAG classifier entry!\n"); |
| return; |
| case DSCP_CLSFR: |
| if (nParms != 3) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n"); |
| return; |
| } |
| newUserTableEntry.Dscp.CodePoint = (U8) parm[2].value; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Removing DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint); |
| break; |
| case PORT_CLSFR: |
| if (nParms != 3) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters(too many?)\n"); |
| return; |
| } |
| newUserTableEntry.Dscp.DstPortNum = (U16) parm[2].value; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Removing PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum); |
| break; |
| case IPPORT_CLSFR: |
| if (nParms != 7) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"PORT_CLSFR Entry type, wrong number of parameters\n"); |
| return; |
| } |
| newUserTableEntry.Dscp.DstIPPort.DstPortNum = (U16) parm[2].value; |
| newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0; |
| for(i=0; i<4; i++) |
| { |
| newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Removing IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n", |
| newUserTableEntry.DTag, |
| newUserTableEntry.Dscp.DstIPPort.DstPortNum, |
| (S32)parm[3].value,(S32)parm[4].value,(S32)parm[5].value,(S32)parm[6].value); |
| break; |
| default: |
| os_error_printf(CU_MSG_INFO2, (PS8)"Unknown Classifier Type - Command aborted!\n"); |
| return; |
| break; |
| } |
| |
| if(CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_REMOVE_CLSFR_ENTRY, |
| &newUserTableEntry, sizeof(clsfr_tableEntry_t))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Failed to remove classifier entry...\n"); |
| } |
| } |
| |
| |
| VOID CuCmd_SetPsRxDelivery(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TPsRxStreaming tPsRxStreaming; |
| |
| tPsRxStreaming.uTid = parm[0].value; |
| tPsRxStreaming.uStreamPeriod = parm[1].value; |
| tPsRxStreaming.uTxTimeout = parm[2].value; |
| tPsRxStreaming.bEnabled = parm[3].value; |
| |
| if (CuCommon_SetBuffer(pCuCmd->hCuCommon, QOS_MNGR_PS_RX_STREAMING, |
| &tPsRxStreaming, sizeof(TPsRxStreaming)) == OK) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Sent PS Rx Delivery to driver..."); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Error: could not set PS Rx Delivery in driver...\n"); |
| } |
| os_error_printf(CU_MSG_INFO2, |
| (PS8)"TID = %d \n RxPeriod = %d \n TxTimeout = %d\n Enabled = %d\n", |
| tPsRxStreaming.uTid, |
| tPsRxStreaming.uStreamPeriod, |
| tPsRxStreaming.uTxTimeout, |
| tPsRxStreaming.bEnabled); |
| } |
| |
| |
| VOID CuCmd_SetQosParams(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_QOS_PARAMS QosParams; |
| |
| QosParams.acID=parm[0].value; |
| QosParams.MaxLifeTime=parm[1].value; |
| QosParams.PSDeliveryProtocol = parm[2].value; |
| |
| if (CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_QOS_PARAMS, |
| &QosParams, sizeof(OS_802_11_QOS_PARAMS)) == OK) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Sent QOS params to driver...\n AC Number=%d \n MaxLifeTime=%d \n PSDeliveryProtocol = %d\n", |
| QosParams.acID, |
| QosParams.MaxLifeTime, |
| QosParams.PSDeliveryProtocol); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Error: could not set QOS params...\n"); |
| } |
| } |
| |
| VOID CuCmd_SetRxTimeOut(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_QOS_RX_TIMEOUT_PARAMS rxTimeOut; |
| |
| rxTimeOut.psPoll = parm[0].value; |
| rxTimeOut.UPSD = parm[1].value; |
| |
| if (nParms != 2) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Please enter Rx Time Out:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - psPoll (0 - 65000)\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - UPSD (1 - 65000)\n"); |
| } |
| else |
| { |
| if(CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_RX_TIMEOUT, |
| &rxTimeOut, sizeof(OS_802_11_QOS_RX_TIMEOUT_PARAMS)) == OK) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Sent QOS Rx TimeOut params to driver...\n PsPoll = %d\n UPSD = %d\n", |
| rxTimeOut.psPoll, |
| rxTimeOut.UPSD); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Error: could not set Rx TimeOut..\n"); |
| } |
| } |
| } |
| |
| VOID CuCmd_RegisterEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms ) |
| { |
| U32 event; |
| S32 res, i; |
| |
| event = (U32)parm[0].value; |
| |
| CU_CMD_FIND_NAME_ARRAY(i, event_type, event); |
| if(i == SIZE_ARR(event_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %d is not defined!\n", event); |
| return; |
| } |
| |
| res = IpcEvent_EnableEvent(pCuCmd->hIpcEvent, event); |
| if (res == EOALERR_IPC_EVENT_ERROR_EVENT_ALREADY_ENABLED) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, event_type, event); |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %s is already enabled!\n", event_type[i].name); |
| return; |
| } |
| |
| } |
| else |
| { |
| print_available_values(event_type); |
| } |
| } |
| |
| VOID CuCmd_UnregisterEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms ) |
| { |
| U32 event; |
| S32 res, i; |
| |
| event = (U32)parm[0].value; |
| |
| CU_CMD_FIND_NAME_ARRAY(i, event_type, event); |
| if(i == SIZE_ARR(event_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %d is not defined!\n", event); |
| return; |
| } |
| |
| res = IpcEvent_DisableEvent(pCuCmd->hIpcEvent, event); |
| if (res == EOALERR_IPC_EVENT_ERROR_EVENT_ALREADY_DISABLED) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, event_type, event); |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_RegisterEvents, event %s is already disabled!\n", event_type[i].name); |
| return; |
| } |
| |
| } |
| else |
| { |
| print_available_values(event_type); |
| } |
| } |
| |
| VOID CuCmd_EnableBtCoe(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| ESoftGeminiEnableModes BtMode; |
| S32 i; |
| |
| named_value_t BtCoe_Mode[] = |
| { |
| { SG_DISABLE, (PS8)"Disable" }, |
| { SG_PROTECTIVE, (PS8)"Protective" }, |
| { SG_OPPORTUNISTIC, (PS8)"Opportunistic" }, |
| }; |
| |
| |
| if(nParms) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, BtCoe_Mode, parm[0].value); |
| if(i == SIZE_ARR(BtCoe_Mode)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_EnableBtCoe, mode %d is not defined!\n", parm[0].value); |
| return; |
| } |
| BtMode = parm[0].value; |
| CuCommon_SetU32(pCuCmd->hCuCommon, SOFT_GEMINI_SET_ENABLE, BtMode); |
| } |
| else |
| { |
| print_available_values(BtCoe_Mode); |
| } |
| } |
| |
| VOID CuCmd_ConfigBtCoe(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 Values[NUM_OF_CONFIG_PARAMS_IN_SG]; |
| U8 Index; |
| |
| if( nParms != NUM_OF_CONFIG_PARAMS_IN_SG ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Please enter <index (0,1..)> <value> \n"); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - coexBtPerThreshold (0 - 10000000) PER threshold in PPM of the BT voice \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - coexAutoScanCompensationMaxTime (0 - 10000000 usec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 2 - coexBtNfsSampleInterval (1 - 65000 msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 3 - coexBtLoadRatio (0 - 100 %) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 4 - coexAutoPsMode (0 = Disabled, 1 = Enabled) Auto Power Save \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 5 - coexHv3AutoScanEnlargedNumOfProbeReqPercent (%) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 6 - coexHv3AutoScanEnlargedScanWinodowPercent (%) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 7 - coexAntennaConfiguration (0 = Single, 1 = Dual)\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 8 - coexMaxConsecutiveBeaconMissPrecent (1 - 100 %) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 9 - coexAPRateAdapationThr - rates (1 - 54)\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 10 - coexAPRateAdapationSnr (-128 - 127)\n"); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 11 - coexWlanPsBtAclMasterMinBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 12 - coexWlanPsBtAclMasterMaxBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 13 - coexWlanPsMaxBtAclMasterBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 14 - coexWlanPsBtAclSlaveMinBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 15 - coexWlanPsBtAclSlaveMaxBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 16 - coexWlanPsMaxBtAclSlaveBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 17 - coexWlanPsBtAclMasterMinEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 18 - coexWlanPsBtAclMasterMaxEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 19 - coexWlanPsMaxBtAclMasterEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 20 - coexWlanPsBtAclSlaveMinEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 21 - coexWlanPsBtAclSlaveMaxEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 22 - coexWlanPsMaxBtAclSlaveEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 23 - coexRxt (usec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 24 - coexTxt (usec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 25 - coexAdaptiveRxtTxt (0 = Disable, 1 = Enable) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 26 - coexPsPollTimeout (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 27 - coexUpsdTimeout (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 28 - coexWlanActiveBtAclMasterMinEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 29 - coexWlanActiveBtAclMasterMaxEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 30 - coexWlanActiveMaxBtAclMasterEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 31 - coexWlanActiveBtAclSlaveMinEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 32 - coexWlanActiveBtAclSlaveMaxEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 33 - coexWlanActiveMaxBtAclSlaveEDR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 34 - coexWlanActiveBtAclMinBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 35 - coexWlanActiveBtAclMaxBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 36 - coexWlanActiveMaxBtAclBR (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 37 - coexHv3AutoEnlargePassiveScanWindowPercent \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 38 - coexA2DPAutoEnlargePassiveScanWindowPercent \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 39 - coexPassiveScanBtTime (msec) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 40 - coexPassiveScanWlanTime (msec)\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 41 - coexTempParam5 \n"); |
| |
| return; |
| } |
| if ((parm[0].value == SOFT_GEMINI_RATE_ADAPT_THRESH) && (CuCmd_IsValueRate(parm[1].value) == FALSE)) |
| { |
| 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"); |
| } |
| else |
| { |
| for (Index = 0; Index < NUM_OF_CONFIG_PARAMS_IN_SG; Index++ ) |
| { |
| Values[Index] = parm[Index].value; |
| /* value[0] - parmater index, value[1] - parameter value */ |
| } |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, SOFT_GEMINI_SET_CONFIG, Values, sizeof(Values)); |
| } |
| } |
| |
| VOID CuCmd_GetBtCoeStatus(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 uDummyBuf; |
| |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, SOFT_GEMINI_GET_CONFIG, |
| &uDummyBuf, sizeof(U32))) |
| { |
| return; |
| } |
| } |
| |
| VOID CuCmd_ConfigCoexActivity(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TCoexActivity tCoexActivity; |
| |
| if( nParms != NUM_OF_COEX_ACTIVITY_PARAMS_IN_SG ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - coexIp (0 - 1) BT-0, WLAN-1 \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 2 - activityId (0 - 24) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 3 - defaultPriority (0 - 255) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 4 - raisedPriority (0 - 255) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 5 - minService (0 - 65535) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 6 - maxService (0 - 65535) \n"); |
| } |
| else |
| { |
| tCoexActivity.coexIp = (U8)parm[0].value; |
| tCoexActivity.activityId = (U8)parm[1].value; |
| tCoexActivity.defaultPriority = (U8)parm[2].value; |
| tCoexActivity.raisedPriority = (U8)parm[3].value; |
| tCoexActivity.minService = (U16)parm[4].value; |
| tCoexActivity.maxService = (U16)parm[5].value; |
| |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TWD_COEX_ACTIVITY_PARAM, |
| &tCoexActivity, sizeof(tCoexActivity)); |
| } |
| } |
| |
| VOID CuCmd_ConfigFmCoex(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TFmCoexParams tFmCoexParams; |
| |
| if (nParms != 10) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"1 - Enable (0 - 1) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"2 - SwallowPeriod (0 - 255) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"3 - NDividerFrefSet1 (0 - 255) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"4 - NDividerFrefSet2 (0 - 255) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"5 - MDividerFrefSet1 (0 - 65535) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"6 - MDividerFrefSet2 (0 - 65535) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"7 - CoexPllStabilizationTime (0 - 4294967295) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"8 - LdoStabilizationTime (0 - 65535) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"9 - FmDisturbedBandMargin (0 - 255) \n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"10- SwallowClkDif (0 - 255) \n"); |
| } |
| else |
| { |
| tFmCoexParams.uEnable = (TI_UINT8)parm[0].value; |
| tFmCoexParams.uSwallowPeriod = (TI_UINT8)parm[1].value; |
| tFmCoexParams.uNDividerFrefSet1 = (TI_UINT8)parm[2].value; |
| tFmCoexParams.uNDividerFrefSet2 = (TI_UINT8)parm[3].value; |
| tFmCoexParams.uMDividerFrefSet1 = (TI_UINT16)parm[4].value; |
| tFmCoexParams.uMDividerFrefSet2 = (TI_UINT16)parm[5].value; |
| tFmCoexParams.uCoexPllStabilizationTime = parm[6].value; |
| tFmCoexParams.uLdoStabilizationTime = (TI_UINT16)parm[7].value; |
| tFmCoexParams.uFmDisturbedBandMargin = (TI_UINT8)parm[8].value; |
| tFmCoexParams.uSwallowClkDif = (TI_UINT8)parm[9].value; |
| |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TWD_FM_COEX_PARAM, &tFmCoexParams, sizeof(TFmCoexParams)); |
| } |
| } |
| |
| VOID CuCmd_SetPowerMode(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TPowerMgr_PowerMode Mode; |
| S32 i; |
| |
| if( nParms ) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, power_mode_val, parm[0].value); |
| if(i == SIZE_ARR(power_mode_val)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPowerMode, mode %d is not defined!\n", parm[0].value); |
| return; |
| } |
| Mode.PowerMode = parm[0].value; |
| Mode.PowerMngPriority = POWER_MANAGER_USER_PRIORITY; |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_SET, |
| &Mode, sizeof(TPowerMgr_PowerMode)); |
| } |
| else |
| { |
| if(!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET, &Mode, sizeof(TPowerMgr_PowerMode))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Power mode: %d\n", Mode.PowerMode); |
| print_available_values(power_mode_val); |
| } |
| } |
| } |
| |
| VOID CuCmd_SetPowerSavePowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 PowerSavePowerLevel; |
| S32 i; |
| |
| if( nParms ) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, power_level, parm[0].value); |
| if(i == SIZE_ARR(power_level)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPowerSavePowerLevel, level %d is not defined!\n", parm[0].value); |
| return; |
| } |
| PowerSavePowerLevel = parm[0].value; |
| CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_PS_SET, PowerSavePowerLevel); |
| } |
| else |
| { |
| if(!CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_PS_GET, &PowerSavePowerLevel)) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, power_level, PowerSavePowerLevel); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Power Level PowerSave is: %s\n", power_level[i].name); |
| print_available_values(power_level); |
| } |
| } |
| } |
| |
| VOID CuCmd_SetDefaultPowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 DefaultPowerLevel; |
| S32 i; |
| |
| if( nParms ) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, power_level, parm[0].value); |
| if(i == SIZE_ARR(power_level)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetDefaultPowerLevel, level %d is not defined!\n", parm[0].value); |
| return; |
| } |
| DefaultPowerLevel = parm[0].value; |
| CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DEFAULT_SET, DefaultPowerLevel); |
| } |
| else |
| { |
| if(!CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DEFAULT_GET, &DefaultPowerLevel)) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, power_level, DefaultPowerLevel); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Power Level Default is: %s\n", power_level[i].name); |
| print_available_values(power_level); |
| } |
| } |
| } |
| |
| VOID CuCmd_SetDozeModeInAutoPowerLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 DozeModeInAutoPowerLevel; |
| S32 i; |
| |
| if( nParms ) |
| { |
| DozeModeInAutoPowerLevel = parm[0].value; |
| |
| if((DozeModeInAutoPowerLevel > AUTO_POWER_MODE_DOZE_MODE_MAX_VALUE) || (DozeModeInAutoPowerLevel < AUTO_POWER_MODE_DOZE_MODE_MIN_VALUE)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetDozeModeInAutoPowerLevel, level %d is not defined!\n", DozeModeInAutoPowerLevel); |
| return; |
| } |
| CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DOZE_MODE_SET, DozeModeInAutoPowerLevel); |
| } |
| else |
| { |
| /* set Short or Long Doze. no use of other parameters */ |
| if(!CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_POWER_LEVEL_DOZE_MODE_GET, &DozeModeInAutoPowerLevel)) |
| { |
| CU_CMD_FIND_NAME_ARRAY(i, power_mode_val, DozeModeInAutoPowerLevel); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Doze power level in auto mode is: %s\n", power_mode_val[i].name); |
| } |
| } |
| } |
| |
| VOID CuCmd_SetTrafficIntensityTh(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS TrafficIntensityTh; |
| |
| if (nParms == 3) |
| { |
| TrafficIntensityTh.uHighThreshold = parm[0].value; |
| TrafficIntensityTh.uLowThreshold = parm[1].value; |
| TrafficIntensityTh.TestInterval = parm[2].value; |
| |
| if (TrafficIntensityTh.uLowThreshold >= TrafficIntensityTh.uHighThreshold) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetTrafficIntensityTh - low threshold equal or greater than the high threshold...aborting...\n"); |
| } |
| |
| if(OK == CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_SET_TRAFFIC_INTENSITY_THRESHOLDS, |
| &TrafficIntensityTh, sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Successfully set traffic intensity thresholds...\n"); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetTrafficIntensityTh - cannot set thresholds\n"); |
| } |
| } |
| else if (nParms == 0) |
| { |
| if(OK == CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_GET_TRAFFIC_INTENSITY_THRESHOLDS, |
| &TrafficIntensityTh, sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Traffic intensity thresholds :\n HighThreshold = %d\n LowThreshold = %d\n TestInterval = %d\n", |
| TrafficIntensityTh.uHighThreshold, |
| TrafficIntensityTh.uLowThreshold, |
| TrafficIntensityTh.TestInterval); |
| } |
| else |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Error - CuCmd_SetTrafficIntensityTh - cannot get thresholds\n"); |
| } |
| } |
| } |
| |
| VOID CuCmd_EnableTrafficEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_TOGGLE_TRAFFIC_INTENSITY_EVENTS, TRUE) ) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Traffic intensity thresholds enabled...\n"); |
| } |
| |
| VOID CuCmd_DisableTrafficEvents(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_TOGGLE_TRAFFIC_INTENSITY_EVENTS, FALSE) ) return; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Traffic intensity thresholds disabled...\n"); |
| } |
| |
| VOID CuCmd_SetDcoItrimParams(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| DcoItrimParams_t dcoItrimParams; |
| |
| if (nParms == 0) |
| { |
| if (OK == CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_DCO_ITRIM_PARAMS, &dcoItrimParams, sizeof(DcoItrimParams_t))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"DCO Itrim Params :\n enable = %d\n moderationTimeoutUsec = %d\n", |
| dcoItrimParams.enable, dcoItrimParams.moderationTimeoutUsec); |
| } |
| else |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Error - CuCmd_SetDcoItrimParams - cannot get DCO Itrim Params\n"); |
| } |
| } |
| |
| else |
| { |
| dcoItrimParams.enable = (Bool_e)parm[0].value; |
| dcoItrimParams.moderationTimeoutUsec = parm[1].value; |
| |
| if (OK == CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_DCO_ITRIM_PARAMS, &dcoItrimParams, sizeof(DcoItrimParams_t))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Successfully set DCO Itrim Params...\n"); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetDcoItrimParams - cannot set DCO Itrim Params\n"); |
| } |
| } |
| } |
| |
| VOID CuCmd_LogAddReport(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 ModuleTable[REPORT_FILES_NUM], ModuleValue[REPORT_FILES_NUM] = {0}; |
| int index = 0; |
| |
| os_memcpy((THandle)ModuleValue, (THandle)(parm[0].value), nParms); |
| |
| for (index = 0; index < REPORT_FILES_NUM; index ++) |
| { |
| if (ModuleValue[index] == '1') |
| { |
| ModuleTable[index] = '1'; |
| } |
| else |
| { |
| ModuleTable[index] = '0'; |
| } |
| } |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, REPORT_MODULE_TABLE_PARAM, ModuleTable, REPORT_FILES_NUM); |
| } |
| |
| VOID CuCmd_LogReportSeverityLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 SeverityTable[REPORT_SEVERITY_MAX]; |
| S32 index = 0; |
| PS8 SeverityValue = (PS8)(parm[0].value); |
| |
| /* Get the current report severity */ |
| if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, REPORT_SEVERITY_TABLE_PARAM, SeverityTable, REPORT_SEVERITY_MAX)) |
| { |
| if(nParms == 0) |
| { |
| S32 i; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Severity:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%14s\tState\t%s\n", (PS8)"Severity level", (PS8)"Desc"); |
| |
| for( i=1; i<SIZE_ARR(report_severity); i++ ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"%d\t%c\t%s\n", report_severity[i].value, (SeverityTable[i] == '1') ? '+' : ' ', report_severity[i].name ); |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"* Use '0' to clear all table.\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to set all table.\n", REPORT_SEVERITY_MAX); |
| } |
| else |
| { |
| for (index = 0; index < REPORT_SEVERITY_MAX; index ++) |
| { |
| if (SeverityValue[index] == '0') |
| { |
| SeverityTable[index] = '0'; |
| } |
| else |
| { |
| SeverityTable[index] = '1'; |
| } |
| } |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, REPORT_SEVERITY_TABLE_PARAM, SeverityTable, REPORT_SEVERITY_MAX); |
| } |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error retriving the severity table from the driver\n"); |
| } |
| } |
| |
| VOID CuCmd_SetReport(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 *pModuleTable = (U8 *)parm[0].value; |
| |
| if( nParms != 1) |
| { |
| U8 ModuleTable[REPORT_FILES_NUM]; |
| S32 i; |
| |
| if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%.5s\tState\t %s\n", (PS8)"Index", (PS8)"Desc"); |
| |
| for( i = 0; i < SIZE_ARR(report_module); i++) |
| { |
| /* Check if there is string content (the first character is not ZERO) */ |
| if( report_module[i].name[0] ) |
| { |
| U8 module_num = (U8) report_module[i].value; |
| os_error_printf(CU_MSG_INFO2, (PS8)"%3d\t%c\t%s\n", |
| module_num, |
| (ModuleTable[module_num] == '1') ? '+' : ' ', |
| report_module[i].name ); |
| } |
| } |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error reading the report table form the driver\n"); |
| } |
| } |
| else |
| { |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_SET, pModuleTable, REPORT_FILES_NUM); |
| } |
| } |
| |
| VOID CuCmd_AddReport(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 ModuleTable[REPORT_FILES_NUM]; |
| |
| if( nParms != 1) |
| { |
| S32 i; |
| if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%.5s\tState\t %s\n", (PS8)"Index", (PS8)"Desc"); |
| |
| for( i = 0; i < SIZE_ARR(report_module); i++) |
| { |
| /* Check if there is string content (the first character is not ZERO) */ |
| if( report_module[i].name[0] ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"%3d\t%c\t%s\n", report_module[i].value, (ModuleTable[i] == '1') ? '+' : ' ', report_module[i].name ); |
| } |
| } |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error reading the report table form the driver\n"); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to set all table.\n", REPORT_FILES_NUM); |
| } |
| else if(!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM)) |
| { |
| if (parm[0].value == REPORT_FILES_NUM) |
| { |
| os_memset(ModuleTable, '1', REPORT_FILES_NUM); |
| } |
| else if(parm[0].value < REPORT_FILES_NUM) |
| { |
| ModuleTable[parm[0].value] = '1'; |
| } |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_SET, ModuleTable, REPORT_FILES_NUM); |
| } |
| } |
| |
| VOID CuCmd_ClearReport(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 ModuleTable[REPORT_FILES_NUM]; |
| |
| if( nParms != 1) |
| { |
| S32 i; |
| if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%.5s\tState\t %s\n", (PS8)"Index", (PS8)"Desc"); |
| |
| for( i = 0; i < SIZE_ARR(report_module); i++) |
| { |
| /* Check if there is string content (the first character is not ZERO) */ |
| if( report_module[i].name[0] ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"%3d\t%c\t%s\n", report_module[i].value, (ModuleTable[i] == '1') ? '+' : ' ', report_module[i].name ); |
| } |
| } |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error reading the report table form the driver\n"); |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to clear all table.\n", REPORT_FILES_NUM); |
| } |
| else if(!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_GET, ModuleTable, REPORT_FILES_NUM)) |
| { |
| if (parm[0].value == REPORT_FILES_NUM) |
| { |
| os_memset(ModuleTable, '0', REPORT_FILES_NUM); |
| } |
| else if(parm[0].value < REPORT_FILES_NUM) |
| { |
| ModuleTable[parm[0].value] = '0'; |
| } |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_MODULE_SET, ModuleTable, REPORT_FILES_NUM); |
| } |
| } |
| |
| VOID CuCmd_ReportSeverityLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U8 SeverityTable[REPORT_SEVERITY_MAX]; |
| |
| /* Get the current report severity */ |
| if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_GET, SeverityTable, REPORT_SEVERITY_MAX)) |
| { |
| if(nParms == 0) |
| { |
| S32 i; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Severity:\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"%14s\tState\t%s\n", (PS8)"Severity level", (PS8)"Desc"); |
| |
| for( i=1; i<SIZE_ARR(report_severity); i++ ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"%d\t%c\t%s\n", report_severity[i].value, (SeverityTable[i] == '1') ? '+' : ' ', report_severity[i].name ); |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"* Use '0' to clear all table.\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to set all table.\n", REPORT_SEVERITY_MAX); |
| } |
| else |
| { |
| if (parm[0].value == 0) |
| { |
| /* Disable all severity levels */ |
| os_memset(SeverityTable, '0', sizeof(SeverityTable)); |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_SET, SeverityTable, REPORT_SEVERITY_MAX); |
| } |
| else if (parm[0].value == REPORT_SEVERITY_MAX) |
| { |
| /* Enable all severity levels */ |
| os_memset(SeverityTable, '1', sizeof(SeverityTable)); |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_SET, SeverityTable, REPORT_SEVERITY_MAX); |
| } |
| else if (parm[0].value < REPORT_SEVERITY_MAX) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Toggle severity level %#lx\n", parm[0].value); |
| if (SeverityTable[parm[0].value] == '1') |
| { |
| /* The level is enabled - Disable it */ |
| SeverityTable[parm[0].value] = '0'; |
| } |
| else |
| { |
| /* The bit is disabled - Enable it */ |
| SeverityTable[parm[0].value] = '1'; |
| } |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_REPORT_SEVERITY_SET, SeverityTable, REPORT_SEVERITY_MAX); |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"invalid level value: %#lx\n", parm[0].value ); |
| } |
| } |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error retriving the severity table from the driver\n"); |
| } |
| } |
| |
| VOID CuCmd_SetReportLevelCLI(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| #if 0 /* need to create debug logic for CLI */ |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S32 i, cli_debug_level; |
| |
| if(nParms) |
| { |
| cli_debug_level = parm[0].value; |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY(i, cli_level_type, cli_debug_level); |
| if(i == SIZE_ARR(cli_level_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetReportLevelCLI, cli_debug_level %d is not defined!\n", cli_debug_level); |
| return; |
| } |
| |
| g_debug_level = cli_debug_level; |
| IpcEvent_UpdateDebugLevel(pCuCmd->hIpcEvent, cli_debug_level); |
| os_error_printf(CU_MSG_INFO2, (PS8)"set CLI debug value = %s \n", cli_level_type[i].name); |
| } |
| else |
| { |
| cli_debug_level = g_debug_level; |
| CU_CMD_FIND_NAME_ARRAY(i, cli_level_type, cli_debug_level); |
| os_error_printf(CU_MSG_INFO2, (PS8)"CLI debug value = %s (%d)\n", cli_level_type[i].name, cli_debug_level); |
| print_available_values(cli_level_type); |
| } |
| #endif |
| } |
| |
| |
| char* SkipSpaces(char* str) |
| { |
| char* tmp = str; |
| |
| while(*tmp == ' ') tmp++; |
| return tmp; |
| } |
| |
| #define ti_isdigit(c) ('0' <= (c) && (c) <= '9') |
| #define ti_islower(c) ('a' <= (c) && (c) <= 'z') |
| #define ti_toupper(c) (ti_islower(c) ? ((c) - 'a' + 'A') : (c)) |
| |
| #define ti_isxdigit(c) (('0' <= (c) && (c) <= '9') \ |
| || ('a' <= (c) && (c) <= 'f') \ |
| || ('A' <= (c) && (c) <= 'F')) |
| |
| #define ti_atol(x) strtoul(x, 0) |
| |
| |
| unsigned long ti_strtoul(char *cp, char** endp, unsigned int base) |
| { |
| unsigned long result = 0, value; |
| |
| if (!base) { |
| base = 10; |
| if (*cp == '0') { |
| base = 8; |
| cp++; |
| if ((ti_toupper(*cp) == 'X') && ti_isxdigit(cp[1])) { |
| cp++; |
| base = 16; |
| } |
| } |
| } else if (base == 16) { |
| if (cp[0] == '0' && ti_toupper(cp[1]) == 'X') |
| cp += 2; |
| } |
| while (ti_isxdigit(*cp) && |
| (value = ti_isdigit(*cp) ? *cp-'0' : ti_toupper(*cp)-'A'+10) < base) { |
| result = result*base + value; |
| cp++; |
| } |
| |
| if(endp) |
| *endp = (char *)cp; |
| |
| return result; |
| } |
| |
| |
| VOID CuCmd_FwDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 *buf_ptr, *pbuf; |
| char *pstr = (char *)parm[0].value; |
| U32 parm_length; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"FwDebug parm: %s\n", parm[0].value); |
| |
| buf_ptr = (U32*)os_MemoryCAlloc(252, sizeof(U32)); |
| if(!buf_ptr) |
| return; |
| |
| pbuf = buf_ptr + 2; |
| |
| pstr = SkipSpaces(pstr); |
| while(*pstr) { |
| *pbuf++ = ti_strtoul(pstr, &pstr, 0); |
| pstr = SkipSpaces(pstr); |
| } |
| |
| parm_length = (U32)((U8*)pbuf-(U8*)buf_ptr); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Parms buf size = %d\n", parm_length); |
| |
| *buf_ptr = 2210; |
| *(buf_ptr+1) = parm_length - 2*sizeof(U32); |
| |
| CuCommon_PrintDriverDebug(pCuCmd->hCuCommon, (PVOID)buf_ptr, parm_length); |
| |
| os_MemoryFree(buf_ptr); |
| |
| } |
| |
| VOID CuCmd_SetRateMngDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| RateMangeParams_t RateParams; |
| |
| RateParams.paramIndex = (TI_UINT8)parm[0].value; |
| |
| |
| if( nParms == 2 ) |
| { |
| switch (RateParams.paramIndex) |
| { |
| case RATE_MGMT_RETRY_SCORE_PARAM: |
| RateParams.RateRetryScore = (TI_UINT16)parm[1].value; |
| break; |
| case RATE_MGMT_PER_ADD_PARAM: |
| RateParams.PerAdd = (TI_UINT16)parm[1].value; |
| break; |
| case RATE_MGMT_PER_TH1_PARAM: |
| RateParams.PerTh1 = (TI_UINT16)parm[1].value; |
| break; |
| case RATE_MGMT_PER_TH2_PARAM: |
| RateParams.PerTh2 = (TI_UINT16)parm[1].value; |
| break; |
| case RATE_MGMT_MAX_PER_PARAM: |
| RateParams.MaxPer = (TI_UINT16)parm[1].value; |
| break; |
| case RATE_MGMT_INVERSE_CURIOSITY_FACTOR_PARAM: |
| RateParams.InverseCuriosityFactor = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_TX_FAIL_LOW_TH_PARAM: |
| RateParams.TxFailLowTh = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_TX_FAIL_HIGH_TH_PARAM: |
| RateParams.TxFailHighTh = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_PER_ALPHA_SHIFT_PARAM: |
| RateParams.PerAlphaShift = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_PER_ADD_SHIFT_PARAM: |
| RateParams.PerAddShift = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_PER_BETA1_SHIFT_PARAM: |
| RateParams.PerBeta1Shift = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_PER_BETA2_SHIFT_PARAM: |
| RateParams.PerBeta2Shift = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_RATE_CHECK_UP_PARAM: |
| RateParams.RateCheckUp = (TI_UINT8)parm[1].value; |
| break; |
| case RATE_MGMT_RATE_CHECK_DOWN_PARAM: |
| RateParams.RateCheckDown = (TI_UINT8)parm[1].value; |
| break; |
| default: |
| os_error_printf(CU_MSG_INFO2,"Error: index is not valid! \n"); |
| return; |
| |
| } |
| } |
| else if ((nParms == NUM_OF_RATE_MNGT_PARAMS_MAX) && (parm[0].value == RATE_MGMT_RATE_RETRY_POLICY_PARAM )) |
| { |
| int i=0; |
| for (i=1; i < NUM_OF_RATE_MNGT_PARAMS_MAX; i++) |
| { |
| RateParams.RateRetryPolicy[i-1] = (TI_UINT8)parm[i].value; |
| } |
| } |
| else |
| { |
| os_error_printf(CU_MSG_INFO2,"(0) RateMngRateRetryScore \n"); |
| os_error_printf(CU_MSG_INFO2,"(1) RateMngPerAdd \n"); |
| os_error_printf(CU_MSG_INFO2,"(2) RateMngPerTh1 \n"); |
| os_error_printf(CU_MSG_INFO2,"(3) RateMngPerTh2 \n"); |
| os_error_printf(CU_MSG_INFO2,"(4) RateMngMaxPer \n"); |
| os_error_printf(CU_MSG_INFO2,"(5) RateMngInverseCuriosityFactor \n"); |
| os_error_printf(CU_MSG_INFO2,"(6) RateMngTxFailLowTh \n"); |
| os_error_printf(CU_MSG_INFO2,"(7) RateMngTxFailHighTh \n"); |
| os_error_printf(CU_MSG_INFO2,"(8) RateMngPerAlphaShift \n"); |
| os_error_printf(CU_MSG_INFO2,"(9) RateMngPerAddShift \n"); |
| os_error_printf(CU_MSG_INFO2,"(10) RateMngPerBeta1Shift \n"); |
| os_error_printf(CU_MSG_INFO2,"(11) RateMngPerBeta2Shift \n"); |
| os_error_printf(CU_MSG_INFO2,"(12) RateMngRateCheckUp \n"); |
| os_error_printf(CU_MSG_INFO2,"(13) RateMngRateCheckDown \n"); |
| os_error_printf(CU_MSG_INFO2,"(14) RateMngRateRetryPolicy[13] \n"); |
| return; |
| } |
| |
| CuCommon_SetBuffer(pCuCmd->hCuCommon, TIWLN_RATE_MNG_SET,&RateParams, sizeof(RateMangeParams_t)); |
| } |
| |
| VOID CuCmd_GetRateMngDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| AcxRateMangeParams ReadRateParams; |
| int i; |
| |
| os_memset(&ReadRateParams,0,sizeof(AcxRateMangeParams)); |
| |
| CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_RATE_MNG_GET, &ReadRateParams, sizeof(AcxRateMangeParams)); |
| |
| if (0 == nParms) |
| { |
| parm[0].value = RATE_MGMT_ALL_PARAMS; |
| } |
| |
| switch (parm[0].value) |
| { |
| case RATE_MGMT_RETRY_SCORE_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngRateRetryScore = %d \n", ReadRateParams.RateRetryScore); |
| break; |
| case RATE_MGMT_PER_ADD_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngPerAdd = %d\n" , ReadRateParams.PerAdd); |
| break; |
| case RATE_MGMT_PER_TH1_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngPerTh1 = %d\n" , ReadRateParams.PerTh1); |
| break; |
| case RATE_MGMT_PER_TH2_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngPerTh2 = %d\n" , ReadRateParams.PerTh2); |
| break; |
| case RATE_MGMT_MAX_PER_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngMaxPer = %d\n" , ReadRateParams.MaxPer); |
| break; |
| case RATE_MGMT_INVERSE_CURIOSITY_FACTOR_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngInverseCuriosityFactor = %d \n" , ReadRateParams.InverseCuriosityFactor); |
| break; |
| case RATE_MGMT_TX_FAIL_LOW_TH_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngTxFailLowTh = %d\n" , ReadRateParams.TxFailLowTh); |
| break; |
| case RATE_MGMT_TX_FAIL_HIGH_TH_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngTxFailHighTh = %d\n" , ReadRateParams.TxFailHighTh); |
| break; |
| case RATE_MGMT_PER_ALPHA_SHIFT_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngPerAlphaShift = %d\n" , ReadRateParams.PerAlphaShift); |
| break; |
| case RATE_MGMT_PER_ADD_SHIFT_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngPerAddShift = %d\n" , ReadRateParams.PerAddShift); |
| break; |
| case RATE_MGMT_PER_BETA1_SHIFT_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngPerBeta1Shift = %d\n" , ReadRateParams.PerBeta1Shift); |
| break; |
| case RATE_MGMT_PER_BETA2_SHIFT_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngPerBeta2Shift = %d\n" , ReadRateParams.PerBeta2Shift); |
| break; |
| case RATE_MGMT_RATE_CHECK_UP_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngRateCheckUp = %d\n" , ReadRateParams.RateCheckUp); |
| break; |
| case RATE_MGMT_RATE_CHECK_DOWN_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngRateCheckDown = %d\n" , ReadRateParams.RateCheckDown); |
| break; |
| case RATE_MGMT_RATE_RETRY_POLICY_PARAM: |
| os_error_printf(CU_MSG_INFO2,"RateMngRateRetryPolicy = "); |
| |
| for (i=0 ; i< RATE_MNG_MAX_RETRY_POLICY_PARAMS_LEN ; i++) |
| { |
| os_error_printf(CU_MSG_INFO2,"%d ",ReadRateParams.RateRetryPolicy[i]); |
| } |
| |
| os_error_printf(CU_MSG_INFO2,"\n"); |
| |
| break; |
| |
| case RATE_MGMT_ALL_PARAMS: |
| os_error_printf(CU_MSG_INFO2,"RateMngRateRetryScore = %d \n", ReadRateParams.RateRetryScore); |
| os_error_printf(CU_MSG_INFO2,"RateMngPerAdd = %d\n" , ReadRateParams.PerAdd); |
| os_error_printf(CU_MSG_INFO2,"RateMngPerTh1 = %d\n" , ReadRateParams.PerTh1); |
| os_error_printf(CU_MSG_INFO2,"RateMngPerTh2 = %d\n" , ReadRateParams.PerTh2); |
| os_error_printf(CU_MSG_INFO2,"RateMngMaxPer = %d\n" , ReadRateParams.MaxPer); |
| os_error_printf(CU_MSG_INFO2,"RateMngInverseCuriosityFactor = %d \n" , ReadRateParams.InverseCuriosityFactor); |
| os_error_printf(CU_MSG_INFO2,"RateMngTxFailLowTh = %d\n" , ReadRateParams.TxFailLowTh); |
| os_error_printf(CU_MSG_INFO2,"RateMngTxFailHighTh = %d\n" , ReadRateParams.TxFailHighTh); |
| os_error_printf(CU_MSG_INFO2,"RateMngPerAlphaShift = %d\n" , ReadRateParams.PerAlphaShift); |
| os_error_printf(CU_MSG_INFO2,"RateMngPerAddShift = %d\n" , ReadRateParams.PerAddShift); |
| os_error_printf(CU_MSG_INFO2,"RateMngPerBeta1Shift = %d\n" , ReadRateParams.PerBeta1Shift); |
| os_error_printf(CU_MSG_INFO2,"RateMngPerBeta2Shift = %d\n" , ReadRateParams.PerBeta2Shift); |
| os_error_printf(CU_MSG_INFO2,"RateMngRateCheckUp = %d\n" , ReadRateParams.RateCheckUp); |
| os_error_printf(CU_MSG_INFO2,"RateMngRateCheckDown = %d\n" , ReadRateParams.RateCheckDown); |
| os_error_printf(CU_MSG_INFO2,"RateMngRateRetryPolicy = "); |
| |
| for (i=0 ; i< RATE_MNG_MAX_RETRY_POLICY_PARAMS_LEN ; i++) |
| { |
| os_error_printf(CU_MSG_INFO2,"%d ",ReadRateParams.RateRetryPolicy[i]); |
| } |
| os_error_printf(CU_MSG_INFO2,"\n"); |
| break; |
| |
| default: |
| os_error_printf(CU_MSG_INFO2,"Error: index is not valid! \n"); |
| return; |
| } |
| |
| } |
| |
| |
| VOID CuCmd_PrintDriverDebug(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 size = 0; |
| TTwdDebug data; |
| |
| /* check if nParam is invalid */ |
| if (( nParms == 0 ) || ( nParms > 4 )) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: Invalid number of Parameters %d\n", nParms); |
| return; |
| } |
| |
| /* init */ |
| os_memset( &data.debug_data.mem_debug.UBuf.buf8, 0, sizeof(data.debug_data.mem_debug.UBuf.buf8) ); |
| data.func_id = parm[0].value; |
| size = sizeof(data.func_id); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: FUN_ID: %u\n", data.func_id); |
| |
| /* if R reg request - read data */ |
| if ( nParms == 2 ) |
| { |
| data.debug_data.opt_param = 4; |
| data.debug_data.opt_param = parm[1].value; |
| size += sizeof(data.debug_data.opt_param); |
| } |
| else |
| /* if W reg request - read data */ |
| if ( nParms > 2 ) |
| { |
| data.debug_data.mem_debug.addr = 0; |
| |
| data.debug_data.mem_debug.length = 4; |
| size += sizeof(data.debug_data.mem_debug.length); |
| |
| data.debug_data.mem_debug.addr = parm[1].value; |
| size += sizeof(data.debug_data.mem_debug.addr); |
| |
| data.debug_data.mem_debug.UBuf.buf32[0] = parm[2].value; |
| size += sizeof(data.debug_data.mem_debug.UBuf.buf32[0]); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: addr: 0x%x\n", data.debug_data.opt_param); |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebug: data: 0x%x\n", data.debug_data.mem_debug.UBuf.buf32[0]); |
| } |
| CuCommon_PrintDriverDebug(pCuCmd->hCuCommon, (PVOID)&data, size); |
| } |
| |
| VOID CuCmd_PrintDriverDebugBuffer(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| U32 func_id = ( nParms > 0 ) ? parm[0].value : 0; |
| U32 opt_param = ( nParms > 1 ) ? parm[1].value : 0; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_PrintDriverDebugBuffer: FUNC:%u, PARAM:%u\n", func_id, opt_param); |
| |
| CuCommon_PrintDriverDebugBuffer(pCuCmd->hCuCommon, func_id, opt_param); |
| } |
| |
| /*-------------------*/ |
| /* Radio Debug Tests */ |
| /*-------------------*/ |
| /* Set the RX channel --> Radio Tune */ |
| VOID CuCmd_RadioDebug_ChannelTune(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TPowerMgr_PowerMode Mode; |
| TTestCmd data; |
| |
| if ((nParms == 0) || (nParms > 2)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - Band (0-2.4Ghz, 1-5Ghz, 2-4.9Ghz)\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - Channel\n"); |
| } |
| else |
| { |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, TIWLN_802_11_POWER_MODE_GET, |
| &Mode, sizeof(TPowerMgr_PowerMode))) return; |
| if(Mode.PowerMode != OS_POWER_MODE_ACTIVE) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Radio tune was not performed becouse Default power-mode is not ACTIVE\n"); |
| } |
| else |
| { |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_CHANNEL_TUNE; |
| data.testCmd_u.Channel.iChannel = (U8)parm[1].value; |
| data.testCmd_u.Channel.iBand = (U8)parm[0].value; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Channel %d tune failed\n",data.testCmd_u.Channel.iChannel); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Channel tune of channel %d was performed OK\n",(U8)data.testCmd_u.Channel.iChannel); |
| } |
| } |
| } |
| |
| /* Start CW test (TELEC) */ |
| VOID CuCmd_RadioDebug_StartTxCw(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| /* check # of params OK */ |
| if ((nParms == 0) || (nParms > 2)) |
| { |
| /* print help */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - Power (0-25000 1/1000 db)\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - Tone Type (1- Carrier Feed Through, 2- Single Tone)\n"); |
| |
| /* os_error_printf(CU_MSG_INFO2, (PS8)"Param 2 - Band\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 3 - Channel\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 4 - PPA Step\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 5 - Tone no. Single Tones\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 6 - Tone no. Two Tones\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 7 - Use digital DC\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 8 - Invert\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 9 - Eleven N Span\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 10 - Digital DC\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 11 - Analog DC Fine\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 12 - Analog DC Course\n");*/ |
| } |
| else |
| { |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_TELEC; |
| data.testCmd_u.TxToneParams.iPower = (U16)parm[0].value; |
| data.testCmd_u.TxToneParams.iToneType = (U8)parm[1].value; |
| /* data.testCmd_u.TxToneParams.iPpaStep = (U8)parm[4].value; |
| data.testCmd_u.TxToneParams.iToneNumberSingleTones = (U8)parm[5].value; |
| data.testCmd_u.TxToneParams.iToneNumberTwoTones = (U8)parm[6].value; |
| data.testCmd_u.TxToneParams.iUseDigitalDC = (U8)parm[7].value; |
| data.testCmd_u.TxToneParams.iInvert = (U8)parm[8].value; |
| data.testCmd_u.TxToneParams.iElevenNSpan = (U8)parm[9].value; |
| data.testCmd_u.TxToneParams.iDigitalDC = (U8)parm[10].value; |
| data.testCmd_u.TxToneParams.iAnalogDCFine = (U8)parm[11].value; |
| data.testCmd_u.TxToneParams.iAnalogDCCoarse = (U8)parm[12].value;*/ |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CW test failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"CW test was performed OK\n"); |
| } |
| } |
| |
| /* Start TX continues test (FCC) */ |
| VOID CuCmd_RadioDebug_StartContinuousTx(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| TMacAddr mac_addr_mask = { 0xff,0xff,0xff,0xff,0xff,0xff }; |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| if ((nParms == 0) || (nParms > 15)) |
| { |
| /* print help */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 0 - Delay\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - Rate\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 2 - Size\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 3 - Amount\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 4 - Power\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 5 - Seed\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 6 - Packet Mode\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 7 - DCF On/Off\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 8 - GI\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 9 - Preamble\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 10 - Type\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 11 - Scrambler\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 12 - Enable CLPC\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 13 - Sequance no. Mode\n"); |
| /* future use. for now the oregenal source address are use. |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 14 - Source MAC Address\n"); |
| */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 14 - Destination MAC Address\n"); |
| } |
| else |
| { |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_FCC; |
| data.testCmd_u.TxPacketParams.iDelay = (U32)parm[0].value; |
| data.testCmd_u.TxPacketParams.iRate = (U32)parm[1].value; |
| data.testCmd_u.TxPacketParams.iSize = (U16)parm[2].value; |
| data.testCmd_u.TxPacketParams.iAmount = (U16)parm[3].value; |
| data.testCmd_u.TxPacketParams.iPower = (U16)parm[4].value; |
| data.testCmd_u.TxPacketParams.iSeed = (U16)parm[5].value; |
| data.testCmd_u.TxPacketParams.iPacketMode = (U8)parm[6].value; |
| data.testCmd_u.TxPacketParams.iDcfOnOff = (U8)parm[7].value; |
| data.testCmd_u.TxPacketParams.iGI = (U8)parm[8].value; |
| data.testCmd_u.TxPacketParams.iPreamble = (U8)parm[9].value; |
| data.testCmd_u.TxPacketParams.iType = (U8)parm[10].value; |
| data.testCmd_u.TxPacketParams.iScrambler = (U8)parm[11].value; |
| data.testCmd_u.TxPacketParams.iEnableCLPC = (U8)parm[12].value; |
| data.testCmd_u.TxPacketParams.iSeqNumMode = (U8)parm[13].value; |
| /* future use. for now the oregenal source address are use. |
| if(!CuCmd_Str2MACAddr((PS8)parm[16].value, (PU8)mac_addr_mask) ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx start has failed to read source MAC Address \n"); |
| return; |
| } |
| */ |
| os_memcpy((PVOID)data.testCmd_u.TxPacketParams.iSrcMacAddr, |
| (PVOID)mac_addr_mask, |
| sizeof(mac_addr_mask)); |
| if(!CuCmd_Str2MACAddr((PS8)parm[14].value, (PU8)mac_addr_mask) ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx start has failed to read destination MAC Address \n"); |
| return; |
| } |
| os_memcpy((PVOID)data.testCmd_u.TxPacketParams.iDstMacAddr, |
| (PVOID)mac_addr_mask, |
| sizeof(mac_addr_mask)); |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx start has failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Continuous Tx started OK\n"); |
| } |
| } |
| |
| /* Stop FCC/TELEC (Radio Debug) */ |
| VOID CuCmd_RadioDebug_StopTx(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_STOP_TX; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Plt Tx Stop has failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Plt Tx Stop was OK\n"); |
| } |
| |
| /* download packet template for transmissions |
| the template shall be set before calling TX Debug */ |
| VOID CuCmd_RadioDebug_Template(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| if ((nParms == 0) || (nParms > 3)) |
| { |
| /* print help */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 1 - Buffer Offset\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Param 2 - Buffer Data\n"); |
| } |
| else |
| { |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_PLT_TEMPLATE; |
| data.testCmd_u.TxTemplateParams.bufferOffset = (U16)parm[0].value; |
| data.testCmd_u.TxTemplateParams.bufferLength = (U16)os_strlen((PS8)parm[1].value); |
| /* check that length is valid */ |
| if( data.testCmd_u.TxTemplateParams.bufferOffset + data.testCmd_u.TxTemplateParams.bufferLength > TX_TEMPLATE_MAX_BUF_LEN ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Plt Template has failed because of invalid buffer length\n"); |
| return; |
| } |
| /* convert the string to hexadeciaml values, and copy it */ |
| CuCmd_atox_string ((U8*)parm[1].value,(U8*)data.testCmd_u.TxTemplateParams.buffer); |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Plt Template has failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Plt Template was OK\n"); |
| } |
| } |
| |
| |
| /* Start RX Statistics */ |
| VOID CuCmd_RadioDebug_StartRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_RX_STAT_START; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Start RX Statistics has failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Start RX Statistics OK\n"); |
| } |
| |
| /* Stop RX Statistics */ |
| VOID CuCmd_RadioDebug_StopRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_RX_STAT_STOP; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Stop RX Statistics has failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Stop RX Statistics OK\n"); |
| } |
| |
| /* Reset RX Statistics */ |
| VOID CuCmd_RadioDebug_ResetRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_RX_STAT_RESET; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Reset RX Statistics has failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Reset RX Statistics OK\n"); |
| } |
| |
| |
| /* Get HDK Version*/ |
| VOID CuCmd_RadioDebug_GetHDKVersion(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| |
| data.testCmdId = TEST_CMD_GET_FW_VERSIONS; |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Get FW version function has failed\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"ProductName: %d\n", data.testCmd_u.fwVersions.hdkVersion.ProductName); |
| os_error_printf(CU_MSG_INFO2, (PS8)"PgNumber: %d\n", data.testCmd_u.fwVersions.hdkVersion.PgNumber); |
| os_error_printf(CU_MSG_INFO2, (PS8)"SoftwareVersionLevel: %d\n", data.testCmd_u.fwVersions.hdkVersion.SoftwareVersionLevel); |
| os_error_printf(CU_MSG_INFO2, (PS8)"radioModuleType: %d\n", data.testCmd_u.fwVersions.hdkVersion.radioModuleType); |
| os_error_printf(CU_MSG_INFO2, (PS8)"SoftwareVersionDelivery: %d\n", data.testCmd_u.fwVersions.hdkVersion.SoftwareVersionDelivery); |
| os_error_printf(CU_MSG_INFO2, (PS8)"numberOfReferenceDesignsSupported: %d\n", data.testCmd_u.fwVersions.hdkVersion.numberOfReferenceDesignsSupported); |
| #ifdef FIX_HDK_VERSION_API /* HDK version struct should be changed aligned and without pointer */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->referenceDesignId: %d\n", data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->referenceDesignId); |
| os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->nvsMajorVersion: %d\n", data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->nvsMajorVersion); |
| os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->nvsMinorVersion: %d\n", data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->nvsMinorVersion); |
| os_error_printf(CU_MSG_INFO2, (PS8)"referenceDesignsSupported->nvsMinorMinorVersion: %d\n", data.testCmd_u.fwVersions.hdkVersion.referenceDesignsSupported->nvsMinorMinorVersion); |
| #endif |
| } |
| |
| /* Get RX Statistics */ |
| VOID CuCmd_RadioDebug_GetRxStatistics(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| #if 0 /*Temp: currently not supported*/ |
| U32 i = 0; |
| #endif |
| |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_RX_STAT_GET; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Get RX Statistics has failed\n"); |
| return; |
| } |
| /* print Statistics Got */ |
| os_error_printf(CU_MSG_INFO2, (PS8)"\n"); |
| 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); |
| 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); |
| 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); |
| 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); |
| /* The RSSI and SNR are in octal units, the value divided by 8 for the print */ |
| 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); |
| 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); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Base Packet ID: %d(0x%x)\n", data.testCmd_u.Statistics.oBasePacketId,data.testCmd_u.Statistics.oBasePacketId); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Number of Packets: %d(0x%x)\n", data.testCmd_u.Statistics.ioNumberOfPackets,data.testCmd_u.Statistics.ioNumberOfPackets); |
| 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); |
| #if 0/*Temp: currently not supported*/ |
| for ( i = 0 ; i < RX_STAT_PACKETS_PER_MESSAGE ; i++ ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"RX Packet %d Statistics\n",i); |
| 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); |
| 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); |
| 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); |
| 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); |
| 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); |
| 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); |
| 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); |
| 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); |
| 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); |
| } |
| #endif |
| } |
| |
| |
| /*-----------*/ |
| /* BIP Tests */ |
| /*-----------*/ |
| |
| |
| void nvsFillMACAddress(THandle hCuCmd, FILE *nvsBinFile) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TMacAddr Mac; |
| U8 lengthToSet; |
| U8 addressHigher; |
| U8 addressLower; |
| U8 valueToSet=0; |
| |
| lengthToSet = 0x1; |
| |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Entering FillMACAddressToNVS\n"); |
| /* param 0 in nvs*/ |
| os_fwrite(&lengthToSet, sizeof(U8), 1, nvsBinFile); |
| |
| /* register for MAC Address*/ |
| addressHigher = 0x6D; |
| addressLower = 0x54; |
| |
| /* param 1 in nvs*/ |
| os_fwrite(&addressHigher, sizeof(U8), 1, nvsBinFile); |
| /* param 2 in nvs*/ |
| os_fwrite(&addressLower, sizeof(U8), 1, nvsBinFile); |
| |
| |
| /* read mac address */ |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, CTRL_DATA_MAC_ADDRESS, Mac, sizeof(TMacAddr))) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Unable to get Mac address, aborting\n"); |
| return; |
| } |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mac[0]=%02x\n", Mac[0]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mac[1]=%02x\n", Mac[1]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mac[2]=%02x\n", Mac[2]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mac[3]=%02x\n", Mac[3]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mac[4]=%02x\n", Mac[4]); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mac[5]=%02x\n", Mac[5]); |
| |
| /* write the lower MAC address starting from the LSB |
| params 3-6 in NVS*/ |
| os_fwrite(&Mac[5], sizeof(U8), 1, nvsBinFile); |
| os_fwrite(&Mac[4], sizeof(U8), 1, nvsBinFile); |
| os_fwrite(&Mac[3], sizeof(U8), 1, nvsBinFile); |
| os_fwrite(&Mac[2], sizeof(U8), 1, nvsBinFile); |
| |
| /* param 7 in NVS*/ |
| os_fwrite(&lengthToSet, sizeof(U8), 1, nvsBinFile); |
| |
| addressHigher = 0x71; |
| addressLower = 0x54; |
| |
| /* params 8-9 in NVS*/ |
| os_fwrite(&addressHigher, sizeof(U8), 1, nvsBinFile); |
| os_fwrite(&addressLower, sizeof(U8), 1, nvsBinFile); |
| |
| |
| /* Write the higher MAC address starting from the LSB |
| params 10-13 in NVS*/ |
| os_fwrite(&Mac[1], sizeof(U8), 1, nvsBinFile); |
| os_fwrite(&Mac[0], sizeof(U8), 1, nvsBinFile); |
| |
| os_fwrite(&valueToSet, sizeof(U8), 1, nvsBinFile); |
| os_fwrite(&valueToSet, sizeof(U8), 1, nvsBinFile); |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"exiting FillMACAddressToNVS\n"); |
| } |
| |
| TI_BOOL nvsReadFile(TI_UINT8 *pReadBuffer, TI_UINT16 *length, char* nvsFilePath) |
| { |
| FILE *nvsBinFile = NULL; |
| TI_UINT8 nvsData; |
| TI_INT8 nvsFileValid = TRUE; |
| TI_UINT32 index =0; |
| |
| if (NULL == (nvsBinFile = os_fopen (nvsFilePath, OS_FOPEN_READ_BINARY))) |
| { |
| nvsFileValid = FALSE; |
| return TI_FALSE; |
| } |
| |
| do |
| { |
| os_fread(&nvsData, sizeof(TI_UINT8), 1, nvsBinFile); |
| pReadBuffer[index++] = nvsData; |
| } while((!feof(nvsBinFile)) && (index < NVS_TOTAL_LENGTH)) ; |
| |
| *length = index; |
| os_fclose(nvsBinFile); |
| |
| return TI_TRUE; |
| } |
| |
| |
| VOID nvsParsePreviosOne(const uint8 *nvsBuffer, TNvsStruct *nvsTypeTLV, uint32 *nvsVersion) |
| { |
| #define BUFFER_INDEX bufferIndex + START_PARAM_INDEX + infoModeIndex |
| |
| uint16 bufferIndex; |
| uint8 tlvType; |
| uint16 tlvLength; |
| uint16 infoModeIndex; |
| NVSTypeInfo nvsTypeInfo; |
| uint8 nvsVersionOctetIndex; |
| uint8 shift; |
| |
| for (bufferIndex = 0; bufferIndex < NVS_TOTAL_LENGTH;) |
| { |
| tlvType = nvsBuffer[bufferIndex]; |
| |
| /* fill the correct mode to fill the NVS struct buffer */ |
| /* if the tlvType is the last type break from the loop */ |
| switch(tlvType) |
| { |
| case eNVS_RADIO_TX_PARAMETERS: |
| nvsTypeInfo = eNVS_RADIO_TX_TYPE_PARAMETERS_INFO; |
| break; |
| |
| case eNVS_RADIO_RX_PARAMETERS: |
| nvsTypeInfo = eNVS_RADIO_RX_TYPE_PARAMETERS_INFO; |
| break; |
| |
| case eNVS_VERSION: |
| for (*nvsVersion = 0, nvsVersionOctetIndex = 0; nvsVersionOctetIndex < NVS_VERSION_PARAMETER_LENGTH; nvsVersionOctetIndex++) |
| { |
| shift = 8 * (NVS_VERSION_PARAMETER_LENGTH - 1 - nvsVersionOctetIndex); |
| *nvsVersion += ((nvsBuffer[bufferIndex + START_PARAM_INDEX + nvsVersionOctetIndex]) << shift); |
| } |
| break; |
| |
| case eTLV_LAST: |
| default: |
| return; |
| } |
| |
| tlvLength = (nvsBuffer[bufferIndex + START_LENGTH_INDEX + 1] << 8) + nvsBuffer[bufferIndex + START_LENGTH_INDEX]; |
| |
| /* if TLV type is not NVS version fill the NVS structure according to the mode TX/RX */ |
| if ((eNVS_RADIO_TX_PARAMETERS == tlvType) || (eNVS_RADIO_RX_PARAMETERS == tlvType)) |
| { |
| nvsTypeTLV[nvsTypeInfo].Type = tlvType; |
| nvsTypeTLV[nvsTypeInfo].Length = tlvLength; |
| |
| for (infoModeIndex = 0; (infoModeIndex < tlvLength) && (BUFFER_INDEX < NVS_TOTAL_LENGTH); infoModeIndex++) |
| { |
| nvsTypeTLV[nvsTypeInfo].Buffer[infoModeIndex] = nvsBuffer[BUFFER_INDEX]; |
| } |
| |
| } |
| |
| /* increment to the next TLV */ |
| bufferIndex += START_PARAM_INDEX + tlvLength; |
| } |
| } |
| |
| |
| VOID nvsFillOldRxParams(FILE *nvsBinFile, const TI_UINT8 *buffer, const uint16 rxLength) |
| { |
| TI_UINT16 index; |
| TI_UINT8 rxTypeValue; |
| TI_UINT8 valueToSet; |
| |
| /* RX BiP type */ |
| rxTypeValue = eNVS_RADIO_RX_PARAMETERS; |
| fwrite(&rxTypeValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* RX BIP Length */ |
| fwrite(&rxLength, sizeof(TI_UINT16), 1, nvsBinFile); |
| |
| for (index = 0; index < rxLength; index++) |
| { |
| valueToSet = buffer[index]; |
| fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| } |
| |
| VOID nvsFillTXParams(FILE *nvsBinFile, TI_UINT8 *nvsPtr, TI_UINT16 txParamLength) |
| { |
| TI_UINT8 txParamValue; |
| TI_UINT8 valueToSet; |
| TI_UINT16 index; |
| |
| /* TX BiP type */ |
| txParamValue = eNVS_RADIO_TX_PARAMETERS; |
| os_fwrite(&txParamValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* TX Bip Length */ |
| os_fwrite(&txParamLength, sizeof(TI_UINT16), 1, nvsBinFile); |
| |
| for (index = 0; index < txParamLength; index++) |
| { |
| valueToSet = nvsPtr[index]; |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| } |
| |
| VOID nvsFillDefaultRXParams(FILE *nvsBinFile) |
| { |
| TI_UINT8 typeValue = eNVS_RADIO_RX_PARAMETERS; |
| TI_UINT16 lengthValue = NVS_RX_PARAM_LENGTH; |
| TI_UINT8 valueToSet = DEFAULT_EFUSE_VALUE; |
| TI_UINT8 rxParamIndex; |
| |
| /* RX type */ |
| os_fwrite(&typeValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* RX length */ |
| os_fwrite(&lengthValue, sizeof(TI_UINT16), 1, nvsBinFile); |
| |
| for (rxParamIndex = 0; rxParamIndex < lengthValue; rxParamIndex++) |
| { |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| } |
| |
| |
| void nvsFillOldTXParams(FILE *nvsBinFile, const TI_UINT8 *buffer, const uint16 txParamLength) |
| { |
| TI_UINT16 index; |
| TI_UINT8 rxTypeValue; |
| TI_UINT8 valueToSet; |
| TI_UINT16 tlvLength; |
| |
| /* TX BiP type */ |
| rxTypeValue = eNVS_RADIO_TX_PARAMETERS; |
| os_fwrite(&rxTypeValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* TX BIP Length */ |
| tlvLength = txParamLength; |
| os_fwrite(&tlvLength, sizeof(TI_UINT16), 1, nvsBinFile); |
| |
| for (index = 0; index < txParamLength; index++) |
| { |
| valueToSet = buffer[index]; |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| } |
| |
| |
| VOID nvsFillDefaultTXParams(FILE *nvsBinFile, const uint16 txParamLength) |
| { |
| TI_UINT32 index; |
| TI_UINT32 lengthOfP2Gtable = NVS_TX_P2G_TABLE_LENGTH; |
| TI_UINT8 p2GValue = 0; |
| TI_UINT32 lengthOfPPASTepTable = NVS_TX_PPA_STEPS_TABLE_LENGTH; |
| TI_UINT8 ppaStesValue = 0; |
| TI_UINT32 lengthOfPDBufferTable = NVS_TX_PD_TABLE_LENGTH_NVS_V2; |
| TI_UINT8 pdStesValue = 0; |
| TI_UINT8 typeValue = eNVS_RADIO_TX_PARAMETERS; |
| TI_UINT16 lengthValue = txParamLength; |
| TI_UINT8 perChannelGainOffsetValue = 0; |
| TI_UINT16 lengthOfGainOffsetTable = NUMBER_OF_RADIO_CHANNEL_INDEXS_E; |
| |
| /* TX type */ |
| os_fwrite(&typeValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* TX length */ |
| os_fwrite(&lengthValue, sizeof(TI_UINT16), 1, nvsBinFile); |
| |
| /* P2G table */ |
| for (index = 0; index < lengthOfP2Gtable; index++) |
| { |
| os_fwrite(&p2GValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| |
| /* PPA steps table */ |
| for (index = 0; index < lengthOfPPASTepTable; index++) |
| { |
| os_fwrite(&ppaStesValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| |
| /* Power Detector */ |
| for (index = 0; index < lengthOfPDBufferTable; index++) |
| { |
| os_fwrite(&pdStesValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| |
| /* Per Channel Gain Offset */ |
| for (index = 0; index < lengthOfGainOffsetTable; index++) |
| { |
| os_fwrite(&perChannelGainOffsetValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| } |
| |
| void nvsFillRXParams(FILE *nvsBinFile, uint8 *nvsPtr, uint16 rxLength) |
| { |
| TI_UINT8 rxTypeValue; |
| TI_UINT8 valueToSet; |
| TI_UINT16 index; |
| |
| /* RX BiP type */ |
| rxTypeValue = eNVS_RADIO_RX_PARAMETERS; |
| os_fwrite(&rxTypeValue, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* RX Bip Length */ |
| os_fwrite(&rxLength, sizeof(TI_UINT16), 1, nvsBinFile); |
| |
| for (index = 0; index < rxLength; index++) |
| { |
| valueToSet = nvsPtr[index]; |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| } |
| |
| |
| VOID nvsFillVersion(FILE *nvsBinFile, TI_UINT32 version) |
| { |
| char versionBuffer[NVS_VERSION_PARAMETER_LENGTH]; |
| TI_UINT8 shift8; |
| TI_UINT8 valueToSet; |
| TI_UINT32 comparison; |
| TI_INT16 index; |
| TI_UINT16 lengthToSet; |
| |
| /* version type */ |
| valueToSet = eNVS_VERSION; |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* version length */ |
| lengthToSet = NVS_VERSION_PARAMETER_LENGTH; |
| os_fwrite(&lengthToSet, sizeof(TI_UINT16), 1, nvsBinFile); |
| |
| for (shift8 = 0, comparison = 0xff, index = NVS_VERSION_PARAMETER_LENGTH - 1;index >= 0; index--) |
| { |
| valueToSet = (version & comparison) >> shift8; |
| versionBuffer[index] = valueToSet; |
| |
| comparison <<= 8; |
| shift8 += 8; |
| } |
| |
| for (index = 0; index < NVS_VERSION_PARAMETER_LENGTH; index++) |
| { |
| os_fwrite(&versionBuffer[index], sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| } |
| |
| |
| VOID nvsWriteEndNVS(FILE *nvsBinFile) |
| { |
| TI_UINT8 valueToSet; |
| TI_UINT16 lengthToSet; |
| |
| /* version type */ |
| valueToSet = eTLV_LAST; |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| valueToSet = eTLV_LAST; |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| |
| /* version length */ |
| lengthToSet = 0; |
| os_fwrite(&lengthToSet, sizeof(TI_UINT16), 1, nvsBinFile); |
| } |
| |
| VOID nvsUpdateFile(THandle hCuCmd, TNvsStruct nvsStruct, TI_UINT8 version, S8 updatedProtocol) |
| { |
| #ifdef _WINDOWS |
| PS8 nvsFilePath = (PS8)"/windows/nvs_map.bin"; |
| #else |
| PS8 nvsFilePath = (PS8)"./nvs_map.bin"; |
| #endif /*_WINDOWS*/ |
| TI_UINT8 currentNVSbuffer[1500]; |
| TI_UINT16 lengthOfCurrentNVSBufer; |
| TI_BOOL prevNVSIsValid; |
| TNvsStruct oldNVSParam[eNUMBER_RADIO_TYPE_PARAMETERS_INFO]; |
| FILE *nvsBinFile; |
| TI_UINT8 index; |
| TI_UINT8 valueToSet = 0; |
| TI_UINT16 nvsTXParamLength = NVS_TX_PARAM_LENGTH_NVS_V2; |
| TI_UINT16 oldNVSTXParamLength; |
| TI_UINT32 oldNVSVersion; |
| TI_UINT32 currentNVSVersion = NVS_VERSION_2; |
| |
| /* read previous NVS if exists */ |
| prevNVSIsValid = nvsReadFile(currentNVSbuffer, &lengthOfCurrentNVSBufer, nvsFilePath); |
| |
| if (prevNVSIsValid) |
| { |
| /* fill the TLV structure for the mode TX/RX */ |
| os_memset(oldNVSParam, 0, eNUMBER_RADIO_TYPE_PARAMETERS_INFO * sizeof(TNvsStruct)); |
| nvsParsePreviosOne(¤tNVSbuffer[NVS_PRE_PARAMETERS_LENGTH], oldNVSParam, &oldNVSVersion); |
| |
| if (currentNVSVersion == oldNVSVersion) |
| { |
| oldNVSTXParamLength = NVS_TX_PARAM_LENGTH_NVS_V2; |
| |
| /* if read all the parameter (needed) from the previous NVS */ |
| if ((oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Type != eNVS_RADIO_TX_PARAMETERS) || |
| (oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Length != nvsTXParamLength) || |
| (oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Type != eNVS_RADIO_RX_PARAMETERS) || |
| (oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Length != NVS_RX_PARAM_LENGTH)) |
| { |
| /* the parameters are wrong */ |
| prevNVSIsValid = TI_FALSE; |
| } |
| else |
| { |
| /* the parameters are right */ |
| prevNVSIsValid = TI_TRUE; |
| } |
| } |
| else |
| { |
| /* there isn't NVS */ |
| prevNVSIsValid = TI_FALSE; |
| } |
| } |
| |
| nvsBinFile = os_fopen(nvsFilePath, OS_FOPEN_WRITE_BINARY); |
| |
| if (NULL == nvsBinFile) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"\n Could not create FILE!!! !!!! \n"); |
| } |
| |
| /* fill MAC Address */ |
| nvsFillMACAddress(hCuCmd, nvsBinFile); |
| |
| /* fill end burst transaction zeros */ |
| for (index = 0; index < NVS_END_BURST_TRANSACTION_LENGTH; index++) |
| { |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| |
| /* fill zeros to Align TLV start address */ |
| for (index = 0; index < NVS_ALING_TLV_START_ADDRESS_LENGTH; index++) |
| { |
| os_fwrite(&valueToSet, sizeof(TI_UINT8), 1, nvsBinFile); |
| } |
| |
| /* Getting from TX BiP Command */ |
| if(NVS_FILE_TX_PARAMETERS_UPDATE == updatedProtocol) |
| { |
| // Fill new TX BiP values |
| nvsFillTXParams(nvsBinFile, nvsStruct.Buffer, nvsStruct.Length); |
| |
| if (prevNVSIsValid) |
| { |
| /* set Parameters of RX from the previous file */ |
| nvsFillOldRxParams(nvsBinFile, oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Buffer, |
| oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Length); |
| } |
| else |
| { |
| nvsFillDefaultRXParams(nvsBinFile); |
| } |
| } |
| /* Getting from RX BiP Command */ |
| else if (NVS_FILE_RX_PARAMETERS_UPDATE == updatedProtocol) |
| { |
| if (prevNVSIsValid) |
| { |
| // set Parameters of TX from the previous file |
| nvsFillOldTXParams(nvsBinFile, oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Buffer, |
| oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Length); |
| } |
| else |
| { |
| nvsFillDefaultTXParams(nvsBinFile, nvsTXParamLength); |
| } |
| |
| /* Fill new RX BiP values */ |
| nvsFillRXParams(nvsBinFile, nvsStruct.Buffer, nvsStruct.Length); |
| |
| } |
| else /* NVS_FILE_WRONG_UPDATE == updatedProtocol */ |
| { |
| if (prevNVSIsValid) |
| { |
| /* set Parameters of TX from the previous file */ |
| nvsFillOldTXParams(nvsBinFile, |
| oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Buffer, |
| oldNVSParam[eNVS_RADIO_TX_TYPE_PARAMETERS_INFO].Length); |
| |
| /* set Parameters of RX from the previous file */ |
| nvsFillOldRxParams(nvsBinFile, |
| oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Buffer, |
| oldNVSParam[eNVS_RADIO_RX_TYPE_PARAMETERS_INFO].Length); |
| } |
| else |
| { |
| /* set default TX param */ |
| nvsFillDefaultTXParams(nvsBinFile,nvsTXParamLength); |
| |
| /* set default RX param */ |
| nvsFillDefaultRXParams(nvsBinFile); |
| } |
| } |
| |
| /* Fill the NVS version to the NVS */ |
| nvsFillVersion(nvsBinFile, version); |
| |
| /* End of NVS */ |
| nvsWriteEndNVS(nvsBinFile); |
| |
| /* close the file */ |
| os_fclose(nvsBinFile); |
| } |
| |
| VOID CuCmd_BIP_BufferCalReferencePoint(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| #define NUM_OF_PARAMETERS_REF_POINT 3 |
| |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| if(nParms != NUM_OF_PARAMETERS_REF_POINT) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Missing Param1: iReferencePointDetectorValue\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Missing Param2: iReferencePointPower\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Missing Param3: isubBand\n"); |
| return; |
| } |
| else |
| { |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| data.testCmdId = TEST_CMD_UPDATE_PD_REFERENCE_POINT; |
| /* data.testCmd_u.PdBufferCalReferencePoint.iReferencePointDetectorValue = 189; |
| data.testCmd_u.PdBufferCalReferencePoint.iReferencePointPower = 12; |
| data.testCmd_u.PdBufferCalReferencePoint.isubBand = 0; 1- BG 2-*/ |
| |
| data.testCmd_u.PdBufferCalReferencePoint.iReferencePointDetectorValue = parm[0].value; |
| data.testCmd_u.PdBufferCalReferencePoint.iReferencePointPower = parm[1].value; |
| data.testCmd_u.PdBufferCalReferencePoint.isubBand = (U8)parm[2].value; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"BufferCalReferencePoint has failed\n"); |
| return; |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"BufferCalReferencePoint was configured succesfully\n"); |
| } |
| return; |
| } |
| |
| |
| /* P2G Calibration */ |
| VOID CuCmd_BIP_StartBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| U32 i; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| |
| data.testCmdId = TEST_CMD_P2G_CAL; |
| |
| data.testCmd_u.P2GCal.iSubBandMask = 0; |
| for (i = 0; i < 8; i++) |
| { |
| data.testCmd_u.P2GCal.iSubBandMask |= (U8)parm[i].value << i; |
| } |
| |
| if (data.testCmd_u.P2GCal.iSubBandMask == 0) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"At least one sub-band should be enabled\n"); |
| return; |
| } |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Tx calibration start has failed\n"); |
| return; |
| } |
| |
| if (TI_OK != data.testCmd_u.P2GCal.oRadioStatus) { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Tx calibration returned status: %d\n", data.testCmd_u.P2GCal.oRadioStatus); |
| return; |
| } |
| |
| nvsUpdateFile(hCuCmd,data.testCmd_u.P2GCal.oNvsStruct , (TI_UINT8)data.testCmd_u.P2GCal.oNVSVersion, NVS_FILE_TX_PARAMETERS_UPDATE); |
| |
| } |
| |
| VOID CuCmd_BIP_EnterRxBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| |
| data.testCmdId = TEST_CMD_RX_PLT_ENTER; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Enter Rx calibration has failed\n"); |
| return; |
| } |
| |
| |
| if (TI_OK != data.testCmd_u.RxPlt.oRadioStatus) { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Enter Rx calibration returned status: %d\n", data.testCmd_u.RxPlt.oRadioStatus); |
| return; |
| } |
| |
| } |
| |
| |
| VOID CuCmd_BIP_StartRxBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| |
| data.testCmdId = TEST_CMD_RX_PLT_CAL; |
| data.testCmd_u.RxPlt.iExternalSignalPowerLevel = (S32)parm[0].value; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Rx calibration has failed\n"); |
| return; |
| } |
| |
| if (TI_OK != data.testCmd_u.RxPlt.oRadioStatus) { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Rx calibration returned status: %d\n", data.testCmd_u.RxPlt.oRadioStatus); |
| return; |
| } |
| |
| nvsUpdateFile(hCuCmd, data.testCmd_u.RxPlt.oNvsStruct, (TI_UINT8)data.testCmd_u.RxPlt.oNVSVersion, NVS_FILE_RX_PARAMETERS_UPDATE); |
| } |
| |
| VOID CuCmd_BIP_ExitRxBIP(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| TTestCmd data; |
| |
| os_memset(&data, 0, sizeof(TTestCmd)); |
| |
| data.testCmdId = TEST_CMD_RX_PLT_EXIT; |
| |
| if(OK != CuCommon_Radio_Test(pCuCmd->hCuCommon, &data)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Exit Rx calibration has failed\n"); |
| return; |
| } |
| |
| |
| if (TI_OK != data.testCmd_u.RxPlt.oRadioStatus) { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Exit Rx calibration returned status: %d\n", data.testCmd_u.RxPlt.oRadioStatus); |
| return; |
| } |
| |
| } |
| |
| |
| |
| VOID CuCmd_SetPrivacyAuth(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 AuthMode; |
| |
| if( nParms ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting privacy authentication to %ld\n", parm[0].value); |
| AuthMode = parm[0].value; |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| /* we can only accept WEP or OPEN configurations */ |
| if((AuthMode >= os802_11AuthModeOpen) && (AuthMode <= os802_11AuthModeAutoSwitch)) |
| { |
| if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, AuthMode)) return; |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyAuth - cannot set mode (%ld) when Suppl is not present\n", AuthMode); |
| return; |
| } |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_SetAuthMode(pCuCmd->hWpaCore, AuthMode)) return; |
| #endif |
| } |
| } |
| else |
| { |
| #ifdef WPA_ENTERPRISE |
| static named_value_t auth_mode_type[] = { |
| { os802_11AuthModeOpen, (PS8)"Open" }, |
| { os802_11AuthModeShared, (PS8)"Shared" }, |
| { os802_11AuthModeAutoSwitch, (PS8)"AutoSwitch"}, |
| { os802_11AuthModeWPA, (PS8)"WPA" }, |
| { os802_11AuthModeWPAPSK, (PS8)"WPAPSK" }, |
| { os802_11AuthModeWPANone, (PS8)"WPANone" }, |
| { os802_11AuthModeWPA2, (PS8)"WPA2" }, |
| { os802_11AuthModeWPA2PSK, (PS8)"WPA2PSK" }, |
| }; |
| #else |
| static named_value_t auth_mode_type[] = { |
| { os802_11AuthModeOpen, (PS8)"Open" }, |
| { os802_11AuthModeShared, (PS8)"Shared" }, |
| { os802_11AuthModeWPAPSK, (PS8)"WPAPSK" }, |
| { os802_11AuthModeWPA2PSK, (PS8)"WPA2PSK" }, |
| }; |
| #endif |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_EXT_AUTHENTICATION_MODE, &AuthMode)) return; |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetAuthMode(pCuCmd->hWpaCore, &AuthMode)) return; |
| #endif |
| } |
| |
| print_available_values(auth_mode_type); |
| os_error_printf(CU_MSG_INFO2, (PS8)"AuthenticationMode=%d\n", AuthMode ); |
| } |
| } |
| |
| VOID CuCmd_SetPrivacyEap(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_EAP_TYPES EapType; |
| S32 i; |
| named_value_t EapType_type[] = { |
| { OS_EAP_TYPE_NONE, (PS8)"OS_EAP_TYPE_NONE" }, |
| { OS_EAP_TYPE_MD5_CHALLENGE, (PS8)"OS_EAP_TYPE_MD5_CHALLENGE" }, |
| { OS_EAP_TYPE_GENERIC_TOKEN_CARD, (PS8)"OS_EAP_TYPE_GENERIC_TOKEN_CARD" }, |
| { OS_EAP_TYPE_TLS, (PS8)"OS_EAP_TYPE_TLS" }, |
| { OS_EAP_TYPE_LEAP, (PS8)"OS_EAP_TYPE_LEAP" }, |
| { OS_EAP_TYPE_TTLS, (PS8)"OS_EAP_TYPE_TTLS" }, |
| { OS_EAP_TYPE_PEAP, (PS8)"OS_EAP_TYPE_PEAP" }, |
| { OS_EAP_TYPE_MS_CHAP_V2, (PS8)"OS_EAP_TYPE_MS_CHAP_V2" }, |
| { OS_EAP_TYPE_FAST, (PS8)"OS_EAP_TYPE_FAST" } |
| }; |
| |
| /* check if we have supplicant */ |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyEap - cannot set EapType when Suppl is not present\n"); |
| return; |
| } |
| |
| if( nParms ) |
| { |
| EapType = parm[0].value; |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY(i, EapType_type, EapType); |
| if(i == SIZE_ARR(EapType_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPrivacyEap, EapType %d is not defined!\n", EapType); |
| return; |
| } |
| |
| #ifndef NO_WPA_SUPPL |
| |
| if(OK != WpaCore_SetPrivacyEap(pCuCmd->hWpaCore, EapType)) |
| os_error_printf(CU_MSG_INFO2, (PS8)"Error Setting EapType to %ld\n", EapType); |
| else |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting EapType to %ld\n", EapType); |
| |
| #endif |
| /* |
| WEXT phase I |
| TI_SetEAPType( g_id_adapter, (OS_802_11_EAP_TYPES) parm[0].value ); |
| TI_SetEAPTypeDriver( g_id_adapter, (OS_802_11_EAP_TYPES) parm[0].value ); |
| */ |
| |
| } |
| else |
| { |
| print_available_values(EapType_type); |
| } |
| } |
| |
| |
| VOID CuCmd_SetPrivacyEncryption(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 EncryptionType; |
| #ifndef NO_WPA_SUPPL |
| OS_802_11_ENCRYPTION_TYPES EncryptionTypePairWise; |
| OS_802_11_ENCRYPTION_TYPES EncryptionTypeGroup; |
| #endif |
| S32 i; |
| |
| if( nParms ) |
| { |
| EncryptionType = parm[0].value; |
| |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY(i, encrypt_type, EncryptionType); |
| if(i == SIZE_ARR(encrypt_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPrivacyEncryption, EncryptionType %d is not defined!\n", EncryptionType); |
| return; |
| } |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| if((EncryptionType == OS_ENCRYPTION_TYPE_NONE) || (EncryptionType == OS_ENCRYPTION_TYPE_WEP)) |
| { |
| if(OK != CuCommon_SetU32(pCuCmd->hCuCommon, RSN_ENCRYPTION_STATUS_PARAM, (U32)EncryptionType)) return; |
| } |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_SetPrivacyEncryption - can't set EncryptionType %s when not connected to supplicant",encrypt_type[i].name); |
| return; |
| } |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| switch(EncryptionType) |
| { |
| case OS_ENCRYPTION_TYPE_NONE: |
| EncryptionTypePairWise = OS_ENCRYPTION_TYPE_NONE; |
| EncryptionTypeGroup = OS_ENCRYPTION_TYPE_NONE; |
| break; |
| case OS_ENCRYPTION_TYPE_WEP: |
| EncryptionTypePairWise = OS_ENCRYPTION_TYPE_WEP; |
| EncryptionTypeGroup = OS_ENCRYPTION_TYPE_WEP; |
| break; |
| case OS_ENCRYPTION_TYPE_TKIP: |
| EncryptionTypePairWise = OS_ENCRYPTION_TYPE_TKIP; |
| EncryptionTypeGroup = OS_ENCRYPTION_TYPE_TKIP; |
| break; |
| case OS_ENCRYPTION_TYPE_AES: |
| EncryptionTypePairWise = OS_ENCRYPTION_TYPE_AES; |
| EncryptionTypeGroup = OS_ENCRYPTION_TYPE_AES; |
| break; |
| } |
| |
| if(OK != WpaCore_SetEncryptionPairWise(pCuCmd->hWpaCore, EncryptionTypePairWise)) return; |
| if(OK != WpaCore_SetEncryptionGroup(pCuCmd->hWpaCore, EncryptionTypeGroup)) return; |
| #endif |
| |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting privacy encryption to %ld\n", encrypt_type[i]); |
| } |
| else |
| { |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_ENCRYPTION_STATUS_PARAM, &EncryptionType)) return; |
| |
| switch (EncryptionType) |
| { |
| case TWD_CIPHER_NONE: |
| EncryptionType = OS_ENCRYPTION_TYPE_NONE; |
| break; |
| case TWD_CIPHER_WEP: |
| case TWD_CIPHER_WEP104: |
| EncryptionType = OS_ENCRYPTION_TYPE_WEP; |
| break; |
| case TWD_CIPHER_TKIP: |
| EncryptionType = OS_ENCRYPTION_TYPE_TKIP; |
| break; |
| case TWD_CIPHER_AES_WRAP: |
| case TWD_CIPHER_AES_CCMP: |
| EncryptionType = OS_ENCRYPTION_TYPE_AES; |
| break; |
| default: |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_SetPrivacyEncryption - unknown encryption type (%d)",EncryptionType); |
| break; |
| } |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetEncryptionPairWise(pCuCmd->hWpaCore, &EncryptionTypePairWise)) return; |
| if(OK != WpaCore_GetEncryptionGroup(pCuCmd->hWpaCore, &EncryptionTypeGroup)) return; |
| |
| if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_NONE) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_NONE)) |
| EncryptionType = OS_ENCRYPTION_TYPE_NONE; |
| else if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_WEP) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_WEP)) |
| EncryptionType = OS_ENCRYPTION_TYPE_WEP; |
| else if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_TKIP) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_TKIP)) |
| EncryptionType = OS_ENCRYPTION_TYPE_TKIP; |
| else if((EncryptionTypePairWise == OS_ENCRYPTION_TYPE_AES) && (EncryptionTypeGroup == OS_ENCRYPTION_TYPE_AES)) |
| EncryptionType = OS_ENCRYPTION_TYPE_AES; |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_SetPrivacyEncryption - unknown encryption type (%d,%d)",EncryptionTypePairWise, EncryptionTypeGroup); |
| return; |
| } |
| #endif |
| } |
| |
| print_available_values(encrypt_type); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Encryption = %d\n", EncryptionType); |
| } |
| } |
| |
| VOID CuCmd_SetPrivacyKeyType(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| OS_802_11_KEY_TYPES KeyType; |
| S32 i; |
| static named_value_t KeyType_type[] = { |
| { OS_KEY_TYPE_STATIC, (PS8)"STATIC" }, |
| { OS_KEY_TYPE_DYNAMIC, (PS8)"DYNAMIC"} |
| }; |
| |
| /* check if we have supplicant */ |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyEncryptGroup - cannot set encryption Group when Suppl is not present\n"); |
| return; |
| } |
| |
| if( nParms ) |
| { |
| KeyType = parm[0].value; |
| /* check if the param is valid */ |
| CU_CMD_FIND_NAME_ARRAY(i, KeyType_type, KeyType); |
| if(i == SIZE_ARR(KeyType_type)) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"CuCmd_SetPrivacyKeyType - KeyType %d is not defined!\n", KeyType); |
| return; |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting KeyType to %ld\n", KeyType); |
| |
| /* |
| WEXT phase I |
| TI_SetKeyType( g_id_adapter, (OS_802_11_KEY_TYPES)parm[0].value ); |
| */ |
| } |
| else |
| { |
| print_available_values(KeyType_type); |
| } |
| } |
| |
| VOID CuCmd_SetPrivacyMixedMode(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 MixedMode; |
| |
| if( nParms ) |
| { |
| MixedMode = parm[0].value; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting MixedMode to %s\n", (MixedMode)?"True":"False"); |
| |
| CuCommon_SetU32(pCuCmd->hCuCommon, TIWLN_802_11_MIXED_MODE_SET, MixedMode); |
| } |
| else |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, TIWLN_802_11_MIXED_MODE_GET, &MixedMode)) return; |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mixed Mode: 0 - FALSE, 1 - TRUE\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Mixed Mode =%s\n", (MixedMode)?"True":"False"); |
| } |
| } |
| |
| VOID CuCmd_SetPrivacyAnyWpaMode(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| #ifndef NO_WPA_SUPPL |
| U32 anyWpaMode; |
| |
| if( nParms ) |
| { |
| anyWpaMode = parm[0].value; |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting anyWpaMode to %s\n", (anyWpaMode)?"True":"False"); |
| |
| WpaCore_SetAnyWpaMode(pCuCmd->hWpaCore,(U8)anyWpaMode); |
| } |
| else |
| { |
| WpaCore_GetAnyWpaMode(pCuCmd->hWpaCore,(U8 *)&anyWpaMode); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Any WPA Mode: 0 - FALSE, 1 - TRUE\n"); |
| os_error_printf(CU_MSG_INFO2, (PS8)"Any WPA =%s\n", (anyWpaMode)?"True":"False"); |
| } |
| #else |
| os_error_printf(CU_MSG_INFO2, (PS8)"Any Wpa Mode support only in Linux supplicants\n"); |
| #endif |
| } |
| |
| VOID CuCmd_SetPrivacyCredentials(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms == 0 ) |
| return; |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyPskPassPhrase - cannot set Credential password phrase when Suppl is not present\n"); |
| return; |
| } |
| |
| #ifndef NO_WPA_SUPPL |
| |
| if( nParms == 2 ) |
| { |
| WpaCore_SetCredentials(pCuCmd->hWpaCore,(PU8)(parm[0].value),(PU8)(parm[1].value)); |
| } |
| else if( nParms == 1 ) |
| { |
| WpaCore_SetCredentials(pCuCmd->hWpaCore,(PU8)(parm[0].value),NULL); |
| } |
| #endif |
| } |
| |
| VOID CuCmd_SetPrivacyPskPassPhrase(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 IsHexKey = FALSE; |
| U8 buf[WPACORE_MAX_PSK_STRING_LENGTH]; |
| PS8 pPassphrase; |
| S32 len; |
| |
| if( nParms == 0 ) |
| return; |
| |
| /* check if we have supplicant */ |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyPskPassPhrase - cannot set PSK password phrase when Suppl is not present\n"); |
| return; |
| } |
| |
| len = os_strlen((PS8)(parm[0].value)); |
| pPassphrase = ((PS8)parm[0].value); |
| os_memset(buf, 0, WPACORE_MAX_PSK_STRING_LENGTH); |
| |
| |
| if( nParms == 2 ) |
| { |
| if( !os_strcmp( (PS8) parm[1].value, (PS8)"hex") ) |
| IsHexKey = TRUE; |
| else if(!os_strcmp( (PS8) parm[1].value, (PS8)"text")) |
| IsHexKey = FALSE; |
| } |
| |
| if( IsHexKey ) |
| { |
| U8 val_l; |
| U8 val_u; |
| S32 i; |
| |
| if( len != WPACORE_PSK_HEX_LENGTH ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"The hexa PSKPassphrase must be at length of %d hexa digits \n",WPACORE_PSK_HEX_LENGTH); |
| return; |
| } |
| |
| for( i=0; *pPassphrase; i++, pPassphrase++ ) |
| { |
| val_u = CuCmd_Char2Hex(*pPassphrase); |
| if( val_u == ((U8)-1) ) return; |
| val_l = CuCmd_Char2Hex(*(++pPassphrase)); |
| if( val_l == ((U8)-1) ) return; |
| buf[i] = ((val_u << 4) | val_l); |
| } |
| } |
| else |
| { |
| if (len > WPACORE_MAX_PSK_STRING_LENGTH || len < WPACORE_MIN_PSK_STRING_LENGTH) |
| { |
| 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); |
| return; |
| } |
| |
| os_memcpy((PVOID)buf, (PVOID)pPassphrase, len); |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"Setting PSKPassphrase to %s\n", (PS8) parm[0].value); |
| #ifndef NO_WPA_SUPPL |
| WpaCore_SetPskPassPhrase(pCuCmd->hWpaCore, buf); |
| #endif |
| |
| } |
| |
| VOID CuCmd_SetPrivacyCertificate(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if( nParms == 0 ) |
| return; |
| |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_SetPrivacyPskPassPhrase - cannot set Certification when Suppl is not present\n"); |
| return; |
| } |
| #ifndef NO_WPA_SUPPL |
| WpaCore_SetCertificate(pCuCmd->hWpaCore,(PU8)(parm[0].value)); |
| #endif |
| |
| |
| } |
| |
| VOID CuCmd_StopSuppl(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| /* check if we have supplicant */ |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_StopSuppl - cannot stop supplicant when Suppl is not present :-)\n"); |
| return; |
| } |
| #ifndef NO_WPA_SUPPL |
| WpaCore_StopSuppl(pCuCmd->hWpaCore); |
| #endif |
| } |
| |
| VOID CuCmd_ChangeSupplDebugLevels(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| /* check if we have supplicant */ |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"Error - CuCmd_DebugSuppl - cannot debug supplicant when Suppl is not present :-)\n"); |
| return; |
| } |
| #ifndef NO_WPA_SUPPL |
| WpaCore_ChangeSupplDebugLevels(pCuCmd->hWpaCore, parm[0].value, parm[1].value, parm[2].value); |
| #endif |
| } |
| |
| VOID CuCmd_AddPrivacyKey(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| PS8 buf; |
| U32 key_id = 0; |
| U32 def_flag = 0; |
| U32 IsHexKey = TRUE; |
| OS_802_11_WEP data; |
| U8 val_l, val_u; |
| S32 len; |
| |
| buf = (PS8)parm[0].value; |
| key_id = (U32)parm[1].value; |
| if( parm[2].value ) def_flag = 0x80000000; |
| os_memset(data.KeyMaterial,0,sizeof(data.KeyMaterial)); |
| len = os_strlen((PS8)buf); |
| |
| if(key_id > 3) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"the key index must be between 0 and 3\n"); |
| return; |
| } |
| |
| if( nParms >= 4 ) |
| { |
| if( !os_strcmp( (PS8) parm[3].value, (PS8)"hex") ) |
| IsHexKey = TRUE; |
| else if( !os_strcmp( (PS8) parm[3].value, (PS8)"HEX") ) |
| IsHexKey = TRUE; |
| else if(!os_strcmp( (PS8) parm[3].value, (PS8)"text")) |
| IsHexKey = FALSE; |
| else if(!os_strcmp( (PS8) parm[3].value, (PS8)"TEXT")) |
| IsHexKey = FALSE; |
| } |
| |
| if( IsHexKey ) |
| { |
| S32 i; |
| |
| if( len % 2 ) |
| { |
| os_error_printf(CU_MSG_INFO2, (PS8)"The hexa key should be even length\n"); |
| return; |
| } |
| if(len <= 10) /*10 is number of character for key length 40 bit*/ |
| data.KeyLength = 5; |
| else if(len <= 26) /*26 is number of character for key length 128 bit*/ |
| data.KeyLength = 13; |
| else if(len <= 58) /*58 is number of character for key length 256 bit*/ |
| data.KeyLength = 29; |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddPrivacyKey - key length not valid\n" ); |
| return; |
| } |
| |
| for( i=0; *buf; i++, buf++ ) |
| { |
| val_u = CuCmd_Char2Hex(*buf); |
| if(val_u == ((U8)-1)) return; |
| val_l = CuCmd_Char2Hex(*(++buf)); |
| if(val_l == ((U8)-1)) return; |
| data.KeyMaterial[i] = ((val_u << 4) | val_l); |
| } |
| } |
| else /* for ascii key */ |
| { |
| if(len <= 5) /*10 is number of character for key length 40 bit*/ |
| data.KeyLength = 5; |
| else if(len <= 13) /*26 is number of character for key length 128 bit*/ |
| data.KeyLength = 13; |
| else if(len <= 29) /*58 is number of character for key length 256 bit*/ |
| data.KeyLength = 29; |
| else |
| { |
| os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuCmd_AddPrivacyKey - key length not valid\n" ); |
| return; |
| } |
| os_memcpy((PVOID)data.KeyMaterial, (PVOID)buf, len); |
| } |
| |
| data.KeyIndex = def_flag | key_id; |
| data.Length = sizeof(OS_802_11_WEP); |
| |
| /* check if we have supplicant */ |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| CuCommon_AddKey(pCuCmd->hCuCommon, &data); |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| WpaCore_AddKey(pCuCmd->hWpaCore, &data); |
| #endif |
| } |
| } |
| |
| VOID CuCmd_RemovePrivacyKey(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| /* check if we have supplicant */ |
| CuCommon_RemoveKey(pCuCmd->hCuCommon, parm[0].value); |
| } |
| |
| VOID CuCmd_GetPrivacyDefaultKey(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| U32 DefaultKeyId; |
| |
| /* check if we have supplicant */ |
| if (pCuCmd->hWpaCore == NULL) |
| { |
| if(OK != CuCommon_GetU32(pCuCmd->hCuCommon, RSN_DEFAULT_KEY_ID, &DefaultKeyId)) return; |
| } |
| else |
| { |
| #ifndef NO_WPA_SUPPL |
| if(OK != WpaCore_GetDefaultKey(pCuCmd->hWpaCore, &DefaultKeyId)) return; |
| #endif |
| } |
| |
| os_error_printf(CU_MSG_INFO2, (PS8)"WEP default key ID = %d\n", DefaultKeyId ); |
| } |
| |
| VOID CuCmd_EnableKeepAlive (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (OK != CuCommon_SetU32 (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ENA_DIS, 1)) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Unable to enable keep-alive messages\n"); |
| } |
| } |
| |
| VOID CuCmd_DisableKeepAlive (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| if (OK != CuCommon_SetU32 (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ENA_DIS, 0)) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Unable to disable keep-alive messages\n"); |
| } |
| } |
| |
| VOID CuCmd_AddKeepAliveMessage (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t *pCuCmd = (CuCmd_t*)hCuCmd; |
| TKeepAliveTemplate keepAliveParams; |
| |
| if (4 != nParms) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Number of params to add keep-alive message is %d\n", nParms); |
| return; |
| } |
| |
| /* copy keep-alive params */ |
| keepAliveParams.keepAliveParams.index = (U8)parm[ 0 ].value; |
| keepAliveParams.keepAliveParams.interval = parm[ 1 ].value; |
| keepAliveParams.keepAliveParams.trigType = parm[ 2 ].value; |
| keepAliveParams.keepAliveParams.enaDisFlag = 1; /* set to enable */ |
| keepAliveParams.msgBufferLength = os_strlen ((PS8)parm[ 3 ].value); |
| if (0 == (keepAliveParams.msgBufferLength %2)) |
| { |
| keepAliveParams.msgBufferLength = keepAliveParams.msgBufferLength / 2; |
| } |
| else |
| { |
| keepAliveParams.msgBufferLength = (keepAliveParams.msgBufferLength / 2) + 1; |
| } |
| /* convert the string to hexadeciaml values, and copy it */ |
| CuCmd_atox_string ((U8*)parm[ 3 ].value, &keepAliveParams.msgBuffer[ 0 ]); |
| |
| if (TI_OK != CuCommon_SetBuffer(pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ADD_REM, |
| &(keepAliveParams), sizeof(TKeepAliveTemplate))) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Unable to add keep-alive message\n"); |
| } |
| } |
| |
| VOID CuCmd_RemoveKeepAliveMessage (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t *pCuCmd = (CuCmd_t*)hCuCmd; |
| TKeepAliveTemplate keepAliveParams; |
| |
| if (1 != nParms) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Number of params to remove keep-alive message is %d\n", nParms); |
| return; |
| } |
| |
| /* copy keep-alive params */ |
| keepAliveParams.keepAliveParams.index = (U8)parm[ 0 ].value; |
| keepAliveParams.keepAliveParams.enaDisFlag = 0; /* set to disable */ |
| keepAliveParams.keepAliveParams.interval = 1000; /* FW validate all parameters, so some reasonable values must be used */ |
| keepAliveParams.keepAliveParams.trigType = KEEP_ALIVE_TRIG_TYPE_PERIOD_ONLY; |
| |
| if (OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_ADD_REM, |
| &(keepAliveParams), sizeof(TKeepAliveTemplate))) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Unable to remove keep-alive message\n"); |
| } |
| } |
| |
| VOID CuCmd_ShowKeepAlive (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t *pCuCmd = (CuCmd_t*)hCuCmd; |
| TKeepAliveConfig tConfig; |
| U32 uIndex, uNameIndex; |
| S8 msgBuffer[ KEEP_ALIVE_TEMPLATE_MAX_LENGTH * 2 ]; |
| |
| if (OK != CuCommon_GetSetBuffer (pCuCmd->hCuCommon, POWER_MGR_KEEP_ALIVE_GET_CONFIG, |
| &(tConfig), sizeof(TKeepAliveConfig))) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Unable to read keep-alive configuration\n"); |
| } |
| |
| os_error_printf (CU_MSG_ERROR, (PS8)"Keep-Alive configuration:\n" |
| "-------------------------\n"); |
| if (TRUE == tConfig.enaDisFlag) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Keep-Alive global flag set to enabled\n\n"); |
| } |
| else |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Keep-Alive global flag set to disabled\n\n"); |
| } |
| |
| os_error_printf (CU_MSG_ERROR, (PS8)"%-8s %-8s %-9s %-10s %s\n", (PS8)"Index", (PS8)"Enabled", (PS8)"Trig Type", (PS8)"Interval", (PS8)"Pattern"); |
| os_error_printf (CU_MSG_ERROR, (PS8)"-----------------------------------------------\n"); |
| for (uIndex = 0; uIndex < KEEP_ALIVE_MAX_USER_MESSAGES; uIndex++) |
| { |
| if (TRUE == tConfig.templates[ uIndex ].keepAliveParams.enaDisFlag) |
| { |
| CU_CMD_FIND_NAME_ARRAY (uNameIndex, tKeepAliveTriggerTypes, |
| tConfig.templates[ uIndex ].keepAliveParams.trigType); |
| CuCmd_xtoa_string (&(tConfig.templates[ uIndex ].msgBuffer[ 0 ]), |
| tConfig.templates[ uIndex ].msgBufferLength, (U8*)&(msgBuffer[ 0 ])); |
| os_error_printf (CU_MSG_ERROR, (PS8)"%-8d %-8d %-9s %-10d %s\n", uIndex, |
| tConfig.templates[ uIndex ].keepAliveParams.enaDisFlag, |
| tKeepAliveTriggerTypes[ uNameIndex ].name, |
| tConfig.templates[ uIndex ].keepAliveParams.interval, |
| &(msgBuffer[ 0 ])); |
| } |
| else |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"%-8d %-8d %-9s %-10d %s\n", uIndex, 0, (PS8)"N/A", 0, (PS8)"N/A"); |
| } |
| } |
| } |
| |
| |
| VOID CuCmd_SetArpIPFilter (THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| |
| TIpAddr staIp; |
| CuCmd_t *pCuCmd = (CuCmd_t*)hCuCmd; |
| TI_UINT8 length = 4; |
| |
| if (length != nParms) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Error! IP format requires 4 parameters as follows: <Part1> <Part2> <Part3> <Part4> \n"); |
| os_error_printf (CU_MSG_ERROR, (PS8)"Please note! IP of 0 0 0 0 will disable the arp filtering feature \n"); |
| return; |
| } |
| |
| staIp[0] = (TI_UINT8)parm[0].value; |
| staIp[1] = (TI_UINT8)parm[1].value; |
| staIp[2] = (TI_UINT8)parm[2].value; |
| staIp[3] = (TI_UINT8)parm[3].value; |
| |
| |
| if (OK != CuCommon_SetBuffer (pCuCmd->hCuCommon, SITE_MGR_SET_WLAN_IP_PARAM, staIp, length)) |
| { |
| os_error_printf (CU_MSG_ERROR, (PS8)"Unable to configure ARP IP filter \n"); |
| } |
| |
| } |
| |
| VOID CuCmd_ShowAbout(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| S8 FwVesrion[FW_VERSION_LEN]; |
| |
| if(OK != CuCommon_GetBuffer(pCuCmd->hCuCommon, SITE_MGR_FIRMWARE_VERSION_PARAM, |
| FwVesrion, FW_VERSION_LEN)) return; |
| |
| #ifdef XCC_MODULE_INCLUDED |
| os_error_printf(CU_MSG_INFO2, (PS8)"Driver version: %s_XCC\n", |
| SW_VERSION_STR); |
| #elif GEM_SUPPORTED |
| os_error_printf(CU_MSG_INFO2, (PS8)"Driver version: %s_GEM\n", |
| SW_VERSION_STR); |
| #else |
| os_error_printf(CU_MSG_INFO2, (PS8)"Driver version: %s_NOCCX\n", |
| SW_VERSION_STR); |
| #endif/* XCC_MODULE_INCLUDED*/ |
| os_error_printf(CU_MSG_INFO2, (PS8)"Firmware version: %s\n", |
| FwVesrion); |
| |
| } |
| |
| VOID CuCmd_Quit(THandle hCuCmd, ConParm_t parm[], U16 nParms) |
| { |
| CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd; |
| |
| Console_Stop(pCuCmd->hConsole); |
| } |
| |
| |
