xref: /system/wlan/ti/sta_dk_4_0_4_32/CUDK/CLI/cu_cmd.c

/*******************************************************************************
**+--------------------------------------------------------------------------+**
**|                                                                          |**
**| Copyright 1998-2008 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.                                           |**
**|                                                                          |**
**+--------------------------------------------------------------------------+**
*******************************************************************************/

#ifdef _WINDOWS
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#ifndef _WINDOWS
	#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <termios.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/wireless.h>

	#include "tnetwCommon.h"
#endif /* __LINUX__ */

#include "g_tester.h"
#include "wspVer.h"

#include "paramOut.h"
#include "console.h"
#include "ticon.h"
#include "cu_cmd.h"
#include "linux_ioctl_common.h"
#include "802_11Defs.h"

#ifndef _T
#define _T(a)    a
#endif

#ifndef _WINDOWS
TI_HANDLE   g_id_adapter = 0;
#endif

#define MAX_SSID_LEN 32
#define CLI_NUM_OF_TX_CLASFR_CON 4

scan_Params_t appScanParams;
scan_Policy_t scanPolicy;

/*** Roaming Manager configuration parameters ***/
roamingMngrConfigParams_t   roamingMngrConfigParams;

static tiUINT32 events_mask = 0; // TRS:PGK

#define NET_BASIC_MASK      0x80    /* defined in common/src/utils/utils.c */

#define IS_BASIC_RATE(a)    ((a) & NET_BASIC_MASK)

#define RATE_2_MBPS(a)    ((float)((a) & (NET_BASIC_MASK-1))/2)

#define GET_NAME_BY_VALUE(arr, value)    get_name_by_value(arr, SIZE_ARR(arr), value)

#define CHAN_FREQ_TABLE_SIZE        (sizeof(ChanFreq) / sizeof(struct CHAN_FREQ))

#define RATE_TABLE_SIZE             (sizeof(rate2Str) / sizeof(named_value_t))

#define ET_TABLE_SIZE               (sizeof(EtEvent2Str) / sizeof(named_value_t))

/* EarlyTermination DISABLE mode - Should be same as in scan.h */
#define SCAN_ET_COND_DISABLE 0

#define MAX_PSK_STRING_LENGTH       63

#define MIN_PSK_STRING_LENGTH       8

#define PSK_HEXA_LENGTH       64

#define PSK_BUFF_LEN 65

static void get_bssid_list(ConParm_t parm[], U16 nParms, BOOL fullBssidList , OS_802_11_BSSID_EX *pBssid);

static BOOL is_value_rate (tiUINT32 rate)
{

   switch (rate)
   {
   case 1:
   case 2:
   case 5:
   case 6:
   case 9:
   case 11:
   case 12:
   case 18:
   case 22:
   case 24:
   case 36:
   case 48:
   case 54:
      return (TRUE);
   default:
      return (FALSE);
   }

}
static BOOL is_value_rate (tiUINT32 rate);
struct CHAN_FREQ {
    UINT8       chan;
    UINT32      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 power_mode_val[] = {
        { OS_POWER_MODE_AUTO,        "AUTO" },
        { OS_POWER_MODE_ACTIVE,      "ACTIVE" },
        { OS_POWER_MODE_SHORT_DOZE,  "SHORT_DOZE" },
        { OS_POWER_MODE_LONG_DOZE,   "LONG_DOZE" }
};

static named_value_t power_level_val[] = {
        { OS_POWER_LEVEL_ELP,        "ELP" },
        { OS_POWER_LEVEL_PD,      "PD" },
        { OS_POWER_LEVEL_AWAKE,  "AWAKE" }
};

static named_value_t encrypt_type[] = {
        { OS_ENCRYPTION_TYPE_NONE,              "None" },
        { OS_ENCRYPTION_TYPE_WEP,               "WEP"  },
        { OS_ENCRYPTION_TYPE_TKIP,              "TKIP" },
        { OS_ENCRYPTION_TYPE_AES,               "AES" }
};

static named_value_t scanType2Str[] = {
        { SCAN_TYPE_NORMAL_PASSIVE,             "Passive Normal Scan"               },
        { SCAN_TYPE_NORMAL_ACTIVE,              "Active Normal Scan"                },
        { SCAN_TYPE_SPS,                        "Scheduled Passive Scan (SPS)"      },
        { SCAN_TYPE_TRIGGERED_PASSIVE,          "Passive Triggered Scan"            },
        { SCAN_TYPE_TRIGGERED_ACTIVE,           "Active Triggered Scan"             }
};

static named_value_t band2Str[] = {
        { RADIO_BAND_2_4_GHZ,                   "2.4 GHz"                        },
        { RADIO_BAND_5_0_GHZ,                   "5.0 GHz"                        },
        { RADIO_BAND_DUAL,                      "Both   "                        }
};

static named_value_t rate2Str[] = {
        { DRV_RATE_MASK_AUTO,                   "Auto    "                          },
        { DRV_RATE_MASK_1_BARKER,               "1 Mbps  "                          },
        { DRV_RATE_MASK_2_BARKER,               "2 Mbps  "                          },
        { DRV_RATE_MASK_5_5_CCK,                "5.5 Mbps"                          },
        { DRV_RATE_MASK_11_CCK,                 "11 Mbps "                          },
        { DRV_RATE_MASK_22_PBCC,                "22 Mbps "                          },
        { DRV_RATE_MASK_6_OFDM,                 "6 Mbps  "                          },
        { DRV_RATE_MASK_9_OFDM,                 "9 Mbps  "                          },
        { DRV_RATE_MASK_12_OFDM,                "12 Mbps "                          },
        { DRV_RATE_MASK_18_OFDM,                "18 Mbps "                          },
        { DRV_RATE_MASK_24_OFDM,                "24 Mbps "                          },
        { DRV_RATE_MASK_36_OFDM,                "36 Mbps "                          },
        { DRV_RATE_MASK_48_OFDM,                "48 Mbps "                          },
        { DRV_RATE_MASK_54_OFDM,                "54 Mbps "                          }
};

static named_value_t EtEvent2Str[] = {
        { SCAN_ET_COND_DISABLE,                      "ET disabled  "                     },
        { SCAN_ET_COND_BEACON,                       "ET on Beacon "                     },
        { SCAN_ET_COND_PROBE_RESP,                   "ET on Prb Rsp"                     },
        { SCAN_ET_COND_ANY_FRAME,                    "ET on both   "                     }
};

/* used in scan_display */
static char* rate2StrFunc(UINT32 rate)
{
    UINT32 i;

    for ( i = 0; i < RATE_TABLE_SIZE; i++ )
    {
        if ( rate2Str[ i ].value == rate )
            return rate2Str[ i ].name;
    }
    return rate2Str[ 0 ].name;
}

/* used in scan_display */
static char* EtEvent2StrFunc( UINT32 ETCond )
{
    int i;

    for ( i = 0; i < ET_TABLE_SIZE; i++ )
    {
        if ( EtEvent2Str[ i ].value == ETCond )
        {
            return EtEvent2Str[ i ].name;
        }
    }

    return EtEvent2Str[ 0 ].name;
}

/* used in get_bssid_list() */
UINT8 Freq2Chan(UINT32 freq)
{
    UINT32 i;

    for(i=0; i<CHAN_FREQ_TABLE_SIZE; i++)
        if(ChanFreq[i].freq == freq) return ChanFreq[i].chan;

    return 0;
}
/* IPC events Callback */
int cli_receive_ev(IPC_EV_DATA*    pData)
{
    tiUINT8 *buf;
    OS_802_11_QOS_TSPEC_PARAMS *AddTsResult;
    OS_802_11_AUTHENTICATION_REQUEST *request;
	OS_802_11_DISASSOCIATE_REASON_T	 *pDisAssoc;
    OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS *CrossParams;
    OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_CROSS_INDICATION_PARAMS *TrafficIntensityThresholdParams;
	btCoexStatus_t				*btCoexStatus;

#if defined (_WINDOWS)
#endif
    g_tester_receive_event((tiUINT8)((IPC_EVENT_PARAMS *)pData)->uEventType);
#if defined (_WINDOWS)
#endif

    switch(((IPC_EVENT_PARAMS *)pData)->uEventType)
    {
        case IPC_EVENT_ASSOCIATED:
            console_printf_terminal("CLI Event - Associated\n");
// TRS:HLC
/*
#if defined (_WINDOWS)
#endif
*/
//TRS end
        break;
        case IPC_EVENT_DISASSOCIATED:
			pDisAssoc = (OS_802_11_DISASSOCIATE_REASON_T*)pData->uBuffer;
			switch(pDisAssoc->eDisAssocType)
			{
			case OS_DISASSOC_STATUS_UNSPECIFIED:
				console_printf_terminal("CLI Event - Disassociated with unspecified reason (User/SG/Recovery)\n");
				break;
			case OS_DISASSOC_STATUS_AUTH_REJECT:
				if (pDisAssoc->uStatusCode == STATUS_PACKET_REJ_TIMEOUT)
				{
					console_printf_terminal("CLI Event - Disassociated due to no Auth response \n");
				}
				else
				{
					console_printf_terminal("CLI Event - Disassociated due to Auth response packet with reason = %d\n", pDisAssoc->uStatusCode);
				}
				break;
			case OS_DISASSOC_STATUS_ASSOC_REJECT:
				if (pDisAssoc->uStatusCode == STATUS_PACKET_REJ_TIMEOUT)
				{
					console_printf_terminal("CLI Event - Disassociated due to no Assoc response \n");
				}
				else
				{
					console_printf_terminal("CLI Event - Disassociated due to Assoc response packet with reason = %d\n", pDisAssoc->uStatusCode);
				}
			    break;
			case OS_DISASSOC_STATUS_SECURITY_FAILURE:
				console_printf_terminal("CLI Event - Disassociated due to RSN failure\n");
			    break;
			case OS_DISASSOC_STATUS_AP_DEAUTHENTICATE:
				console_printf_terminal("CLI Event - Disassociated due to AP deAuthenticate packet with reason = %d\n", pDisAssoc->uStatusCode);
				break;
			case OS_DISASSOC_STATUS_AP_DISASSOCIATE:
				console_printf_terminal("CLI Event - Disassociated due to AP disAssoc packet with reason = %d\n", pDisAssoc->uStatusCode);
				break;
			case OS_DISASSOC_STATUS_ROAMING_TRIGGER:
				console_printf_terminal("CLI Event - Disassociated due to roaming trigger = %d\n", pDisAssoc->uStatusCode);
				break;
			default:
				console_printf_terminal("CLI Event - Disassociated with unknown reason = %d\n", pDisAssoc->eDisAssocType);
			    break;
			}
        break;
        case IPC_EVENT_LINK_SPEED:
            console_printf_terminal("CLI Event - LinkSpeed\n");
        break;
        case IPC_EVENT_AUTH_SUCC:
            console_printf_terminal("CLI Event - Authentication Success\n");
        break;
        case IPC_EVENT_SCAN_COMPLETE:
            console_printf_terminal("CLI Event - Scan Complete\n");
        break;
        case IPC_EVENT_TIMEOUT:
            console_printf_terminal("CLI Event - Timeout\n");
        break;
        case IPC_EVENT_UNBOUND:
            console_printf_terminal("CLI Event - Unbound\n");
        break;
        case IPC_EVENT_BOUND:
            console_printf_terminal("CLI Event - Bound\n");
        break;
        case IPC_EVENT_EAPOL:
            console_printf_terminal("CLI Event - EAPOL\n");
        break;
        case IPC_EVENT_MEDIA_SPECIFIC:
            buf = pData->uBuffer;
            request = (OS_802_11_AUTHENTICATION_REQUEST *) (buf + sizeof(tiUINT32));
            if( request->Flags == OS_802_11_REQUEST_PAIRWISE_ERROR ||
                request->Flags == OS_802_11_REQUEST_GROUP_ERROR)
            console_printf_terminal("CLI Event - Media_Specific\n");
        break;
        case IPC_EVENT_CCKM_START:
            console_printf_terminal("CLI Event - CCKM_Start\n");
        break;

        case IPC_EVENT_PREAUTH_EAPOL:
            console_printf_terminal("CLI Event - PreAuth EAPOL\n");
            break;

        case IPC_EVENT_LOW_SNR:
            console_printf_terminal("CLI Event - Low SNR\n");
            break;

        case IPC_EVENT_LOW_RSSI:
            console_printf_terminal("CLI Event - Low RSSI\n");
            break;

        case IPC_EVENT_EAP_AUTH_FAILURE:
            {
                OS_802_11_EAP_TYPES eapType;
                tiINT32             status;
                authStatus_e        eAuthStatusReason;

				/* Cast the value to be UINT16 16 bits since it is sent this way in the EXCMngr.c */
                eAuthStatusReason = (authStatus_e)((*(pData->uBuffer)) & 0xFFFF);

                status = TI_GetEAPType( g_id_adapter, &eapType );

                if (eapType == OS_EAP_TYPE_LEAP)
                {
                    console_printf_terminal("CLI Event - LEAP Authentication Failed \n");
                }
                else if (eapType == OS_EAP_TYPE_FAST)
                {
                    console_printf_terminal("CLI Event - EAP-FAST Authentication Failed \n");
                }
                else if (eapType == OS_EAP_TYPE_TLS)
                {
                    console_printf_terminal("CLI Event - EAP-TLS Authentication Failed \n");
                }

                switch ( eAuthStatusReason )
                {
                case RSN_AUTH_STATUS_INVALID_TYPE:
                    console_printf_terminal("The reason: Invalid Authentication Type \n");
                    break;
                case RSN_AUTH_STATUS_TIMEOUT:
                    console_printf_terminal("The reason: Authentication Timeout \n");
                    break;
                case RSN_AUTH_STATUS_CHALLENGE_FROM_AP_FAILED:
                case RSN_AUTH_STATUS_CHALLENGE_TO_AP_FAILED:
                    console_printf_terminal("The reason: username or password incorrect \n");
                    break;
                default:
                    console_printf_terminal("The reason: unknown = %d \n", eAuthStatusReason);
                    break;
                }

            }
            break;

        case IPC_EVENT_TSPEC_STATUS:
           AddTsResult = (OS_802_11_QOS_TSPEC_PARAMS *)pData->uBuffer;
           console_printf_terminal("CLI Event - IPC_EVENT_TSPEC_STATUS -- (userPriority = %d, ReasonCode = %d) \n",AddTsResult->uUserPriority,AddTsResult->uReasonCode);
           console_printf_terminal ("Tspec Parameters (as received through event handler):\n");
           console_printf_terminal ("-----------------------------------------------------\n");
           console_printf_terminal ("userPriority = %d\n",AddTsResult->uUserPriority);
           console_printf_terminal ("uNominalMSDUsize = %d\n",AddTsResult->uNominalMSDUsize);
           console_printf_terminal ("uMeanDataRate = %d\n",AddTsResult->uMeanDataRate);
           console_printf_terminal ("uMinimumPHYRate = %d\n",AddTsResult->uMinimumPHYRate);
           console_printf_terminal ("uSurplusBandwidthAllowance = %d\n",AddTsResult->uSurplusBandwidthAllowance);
           console_printf_terminal ("uAPSDFlag = %d\n",AddTsResult->uAPSDFlag);
           console_printf_terminal ("uMediumTime = %d\n\n",AddTsResult->uMediumTime);
           break;
        case IPC_EVENT_TSPEC_RATE_STATUS:
           CrossParams = (OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS *)pData->uBuffer;
           console_printf_terminal("CLI Event - IPC_EVENT_TSPEC_RATE_STATUS (AC = %d, HighLowFlag = %d, AboveOrBelow = %d)\n",CrossParams->uAC,CrossParams->uHighOrLowThresholdFlag,CrossParams->uAboveOrBelowFlag);
           break;
        case IPC_EVENT_MEDIUM_TIME_CROSS:
           CrossParams = (OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS *)pData->uBuffer;
           console_printf_terminal("CLI Event - IPC_EVENT_MEDIUM_TIME_CROSS (AC = %d, HighLowFlag = %d, AboveOrBelow = %d)\n",CrossParams->uAC,CrossParams->uHighOrLowThresholdFlag,CrossParams->uAboveOrBelowFlag);
           break;
        case IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED:
           TrafficIntensityThresholdParams = (OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_CROSS_INDICATION_PARAMS*)pData->uBuffer;
           printf("CLI Event - IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED\n");
           printf("---------------------------------------------------------\n");
           printf("Threshold crossed: %s Threshold\n", ((TrafficIntensityThresholdParams->uHighOrLowThresholdFlag == HIGH_THRESHOLD_CROSS) ? "High" : "Low"));
           printf("Direction crossed: %s\n\n", ((TrafficIntensityThresholdParams->uAboveOrBelowFlag == CROSS_ABOVE) ? "Above" : "Below"));
           break;

        case IPC_EVENT_WPA2_PREAUTHENTICATION:
            {
                ULONG *WPA2_PreAuth_Status;

               WPA2_PreAuth_Status = (ULONG *)pData->uBuffer;
               printf("CLI Event - IPC_EVENT_WPA2_PREAUTHENTICATION\n");
               printf("Status code = %lu\n",*WPA2_PreAuth_Status);
            }
           break;

        case IPC_EVENT_ROAMING_COMPLETE:
            printf("CLI Event - IPC_EVENT_ROAMING_COMPLETE \n");
        break;

	case IPC_EVENT_BT_COEX_MODE:
		btCoexStatus = (btCoexStatus_t*)pData->uBuffer;
		if (btCoexStatus->state)
		{
			console_printf_terminal("CLI Event - IPC_EVENT_BT_COEX_MODE (SG is ON, minTxRate = %d)\n",btCoexStatus->minTxRate);
		}
		else
		{
			console_printf_terminal("CLI Event - IPC_EVENT_BT_COEX_MODE (SG is OFF)\n");
		}
		break;

        default:
            console_printf_terminal("CLI Event - Unknown event\n");
        break;
    }
    return 0;


}

static char *print_rate(rate_e rate)
{
    static char buf[20];

    if( rate == 0 )
        return "Auto (0)";

    sprintf(buf, "%.3g Mbps (%u%s)", RATE_2_MBPS(rate), rate,
        IS_BASIC_RATE(rate) ? " - basic" : "" );
    return buf;
}

static BOOL isJunkSSID(OS_802_11_SSID *ssid )
{
    if ((ssid == NULL) || (ssid->SsidLength == 0))
    {
        return TRUE;
    }

    if (ssid->SsidLength > 2)
    {
        if ((ssid->Ssid[0] < MAX_SSID_LEN) &&
            (ssid->Ssid[1] < MAX_SSID_LEN) &&
            (ssid->Ssid[2] < MAX_SSID_LEN))
        {
            return TRUE;
        }
    }

    return FALSE;
}

static char *get_ssid_string(OS_802_11_SSID *ssid )
{
    static char tmp_buf[MAX_SSID_LEN+1];
    if ((ssid == NULL) || (ssid->SsidLength == 0) || isJunkSSID(ssid))
        return "<empty>";

    if (ssid->SsidLength < SIZE_ARR(ssid->Ssid))
           ssid->Ssid[ssid->SsidLength] = 0;
    else if( ssid->SsidLength == MAX_SSID_LEN )
    {
        memcpy(tmp_buf, ssid->Ssid, MAX_SSID_LEN );
        tmp_buf[MAX_SSID_LEN] = 0;
        return tmp_buf;
    }
    else
    {
        console_printf_terminal("error: invalid ssid length (len = %u)\n", ssid->SsidLength );
        return "<error>";
    }
    return (char *) ssid->Ssid;
}
/*  return 0 on error
    or 'mac' if success
    'str' format: num.num.num.num.num.num (where 'num' is number from 0 to 255)
*/
U8* str2MACAddr(char *str, U8 *mac)
{
    const int mac_len = 6;
    int i;
    char *p = str;
#ifndef _WINDOWS
    errno = 0;
#endif
    console_printf_terminal("str2MAC():");
    for( i=0; i<mac_len; i++ )
    {
        mac[i] = (U8) strtoul(p, &p, 16);
#ifndef _WINDOWS
        if( errno == ERANGE )
            return NULL;
#endif
        console_printf_terminal("%2x.", mac[i] );
        p++;

    }
    console_printf_terminal("\n");
    return mac;
}

static char * print_mac_2_str(OS_802_11_MAC_ADDRESS mac)
{
    static char buf[30];

    sprintf(buf, "%02x.%02x.%02x.%02x.%02x.%02x",
                mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);

    return buf;
}

/* convert hex MAC addr in the form xx:xx:xx:xx:xx:xx to mac address */
static void hexStr2MACAddr( char *hexStr, macAddress_t* mac )
{
    size_t i;
    char *currHexStrPos = hexStr;
    UINT8 tempValue;

    /* convert hex string to lower */
    for ( i = 0; i < strlen(hexStr); i++ )
    {
        hexStr[ i ] = tolower( hexStr[ i ] );
    }

    /* convert to numbers */
    for ( i = 0; i < 6; i++ )
    {
        tempValue = 0;
        if ( *currHexStrPos >= 'a' )
            tempValue = *currHexStrPos - 'a' + 10;
        else
            tempValue = *currHexStrPos - '0';
        currHexStrPos++;
        tempValue <<= 4;
        if ( *currHexStrPos >= 'a' )
            tempValue += *currHexStrPos - 'a' + 10;
        else
            tempValue += *currHexStrPos - '0';
        currHexStrPos += 2;
        mac->addr[ i ] = tempValue;
    }
}

static void mac2HexStr( macAddress_t* mac, char* hexStr )
{
    sprintf( hexStr, "%02x:%02x:%02x:%02x:%02x:%02x",
        mac->addr[0],mac->addr[1],mac->addr[2],mac->addr[3],mac->addr[4],mac->addr[5]);
}

char *get_name_by_value(named_value_t *arr, int arr_size, UINT32 value)
{
    int i;
    for(i=0; i<arr_size; i++) {
        if( arr[i].value == value )
            return arr[i].name;
    }
    return "<unknow>";
}

void cmd_modify_supported_rates(ConParm_t parm[], U16 nParms)
{
    rates_t data = { 0 };
    char debug_buf[256] = { 0 };
    int i;

    if( nParms == 0 )
    {
        if( !TI_GetSupportedRates(g_id_adapter, (tiUINT8*)&data, sizeof(data)) )
        {
            console_printf_terminal(" Rates: ");
            for( i=0; i<MAX_SUPPORTED_RATES && i < data.len; i++ )
            {
                console_printf_terminal("%g Mbps(%u%s)%s", RATE_2_MBPS(data.ratesString[i]),
                    data.ratesString[i],
                    IS_BASIC_RATE(data.ratesString[i]) ? " - basic" : "",
                    (i < data.len-1) ? "," : "" );
            }
            console_printf_terminal("\n");
        }
    }
    else
    {
        char *end_p, *buf = (char *) parm[0].value;
        float val;
        console_printf_terminal("param: %s\n", buf );
#ifndef _WINDOWS
        errno = 0;
#endif
        for( i=0; *buf && i < MAX_SUPPORTED_RATES; i++ )
        {
            val = (float) strtod(buf, &end_p);
            if(
#ifndef _WINDOWS
			   errno ||
#endif
			   buf == end_p )
            {
                console_printf_terminal("cmd_modify_supported_rates(): invalid value - %s\n", buf );
                return;
            }
            if( val > ((1 << (sizeof(data.ratesString[i]) * 8))-1) )
            {
                console_printf_terminal("cmd_modify_supported_rates(): out of range '%.*s'\n", end_p - buf, buf );
                return;
            }
            data.ratesString[i] = (tiUINT8) (val);

            sprintf(&debug_buf[strlen(debug_buf)], "%g (%d) ", val, data.ratesString[i] );

            buf = end_p;
            while( *buf==' ' || *buf == ',' )   buf++;

        }

        if( *buf )
        {
            console_printf_terminal("too many parameters. Max=%d\n", MAX_SUPPORTED_RATES );
            return;
        }

        data.len = i;
        console_printf_terminal("**set rates (%d) :%s\n", data.len, debug_buf );
        TI_SetSupportedRates(g_id_adapter, (tiUINT8*) &data, sizeof(data));
    }
}

void cmd_show_status(ConParm_t parm[], U16 nParms)
{
    tiINT32 res;
    OS_802_11_BSSID_EX BssIdInfo;

    tiUINT32 data;
    char buf[4096] = { 0 };
    OS_802_11_SSID ssid = { 0 };
    OS_802_11_MAC_ADDRESS bssid = { 0 };

    UNUSED(parm);
    UNUSED(nParms);

    buf[0] = 0;

    res = TI_WLAN_IsDriverRun(g_id_adapter, (tiBOOL *)&data);
    if( res )
        return ;

    sprintf(buf, "Status   : %s\n", res ? "<error>" : (data ? "running" : "stopped") );

    sprintf(&buf[strlen(buf)], "MAC      : ");
    if( !TI_GetCurrentAddress(g_id_adapter, &bssid ) )
        strcat(buf, print_mac_2_str(bssid) );
    else
        strcat(buf, "<error>");

    strcat(buf, "\nSSID     : ");
    if( !TI_GetCurrentSSID(g_id_adapter, &ssid) )
    {
        if (!isJunkSSID(&ssid))
        {
           strncat(buf, get_ssid_string(&ssid),ssid.SsidLength);
        }
        else
        {
           strcat(buf,"<empty>");
        }
    }
    else
        strcat(buf, "<error>" );

    sprintf(&buf[strlen(buf)], "\nBSSID    : ");

   TI_GetSelectedBSSIDInfo(g_id_adapter, &BssIdInfo);
   strcat(buf, print_mac_2_str(BssIdInfo.MacAddress));

    strcat(buf, "\nChannel  : ");
    data = 0;
    if( !TI_GetCurrentChannel(g_id_adapter, &data ) )
    {
        sprintf(&buf[strlen(buf)], "%d", data );
    }
    else
        strcat(buf, "<error>");

    console_printf_terminal("==========================\n%s\n==========================\n\n", buf);
}

void cmd_connect(ConParm_t parm[], U16 nParms)
{
    char buf[1] = { 0 };
    OS_802_11_MAC_ADDRESS bssid = { 0xff,0xff,0xff,0xff,0xff,0xff };

    buf[0] = 0;

    switch (nParms) {

    case 0 :
        /*
         *  No SSID & No BSSID are set -
         *  Use Any SSID & Any BSSID.
         */

        TI_SetBSSID(g_id_adapter, &bssid );
        TI_SetSSID(g_id_adapter, (tiUINT8 *) buf);
        break;

    case 1:
        /*
         *  SSID set & BSSID insn't set  -
         *  Use CLI's SSID & Any BSSID.
         */
        TI_SetBSSID(g_id_adapter, &bssid );
        TI_SetSSID(g_id_adapter, (tiUINT8 *) parm[0].value);
        break;

    case 2:
        /*
         *  Both SSID & BSSID are set -
         *  Use CLI's SSID & BSSID.
         */
        if( !str2MACAddr((char *) parm[1].value, bssid) )
            return;
        TI_SetBSSID(g_id_adapter, &bssid);
        TI_SetSSID(g_id_adapter, (tiUINT8 *) parm[0].value);
        break;
}
}


void cmd_disassociate(ConParm_t parm[], U16 nParms)
{
    UNUSED(parm);
    UNUSED(nParms);

    TI_Disassociate(g_id_adapter);
}

void cmd_show_advanced_params(ConParm_t parm[], U16 nParms)
{
    tiUINT32 mode_4x = 0, preamble = 0xfefefefe;
    OS_802_11_AUTHENTICATION_MODE auth;
    OS_802_11_ENCRYPTION_TYPES encrypt;
    tiUINT32    rts_tresh;
    tiUINT32    frag_tresh = 0xfefefefe;
    tiUINT8     tx_power = 0xfe;
    OS_802_11_POWER_PROFILE power_mode = 0;

    UNUSED(parm);
    UNUSED(nParms);

    TI_GetAuthenticationMode(g_id_adapter, &auth );
    TI_GetTxPowerDbm(g_id_adapter, (tiCHAR*) &tx_power);
    TI_GetFragmentThreshold( g_id_adapter, &frag_tresh);
    TI_GetRTSThreshold( g_id_adapter, &rts_tresh);
    TI_Get4XState( g_id_adapter, &mode_4x);
    TI_GetEncryptionType( g_id_adapter, &encrypt );
    TI_GetPowerMode(g_id_adapter, (OS_802_11_POWER_PROFILE*) &power_mode );
    console_printf_terminal("  Authentication : %u\n", auth );
    console_printf_terminal("      Power mode : %d\n", (tiUINT32) power_mode );
    console_printf_terminal("  Tx Power (Dbm/10 units) : %d\n", tx_power );

    console_printf_terminal("      Encryption : %u\n", encrypt );
    console_printf_terminal("        Preamble : <%s>\n", (preamble) ? "short" : "long");
/*    console_printf_terminal("      Tx antenna : %u\n", tx_ant );*/
/*    console_printf_terminal(  "      Rx antenna : %u\n", rx_ant );*/
/*    console_printf_terminal(  "Ap Tx power level: n/a\n" );*/
/*    console_printf_terminal(  "  Tx power value : %lu\n", tx_power_val );*/
/*    console_printf_terminal(  "     MAC address : n/a\n" );*/
    console_printf_terminal(  "        4X state : %d\n", mode_4x );
/*     console_printf_terminal(  "        B/G mode : n/a\n" );*/
/*     console_printf_terminal(  "    Country code : n/a\n" );*/
/*     console_printf_terminal(  "      IP address : n/a\n" );*/
/*     console_printf_terminal(  "        Net mask : n/a\n" );*/
/*     console_printf_terminal(  "         Gateway : n/a\n" );*/
    console_printf_terminal(  " Frag. threshold : %u\n", frag_tresh);
    console_printf_terminal(  "   RTS threshold : %u\n", rts_tresh );

    console_printf_terminal(  "Power mode: ");
    print_available_values(power_mode_val);

    console_printf_terminal(  "Encryption type: ");
    print_available_values(encrypt_type);
}

void cmd_show_statistics(ConParm_t parm[], U16 nParms)
{
    TIWLN_STATISTICS statistics = { 0 } ;

    UNUSED(parm);
    UNUSED(nParms);

    console_printf_terminal(  "TI_GetStatistics(%s, data=%p, size=%d\n", (char*) g_id_adapter, &statistics, sizeof(statistics) );

    if( TI_GetStatistics( g_id_adapter, &statistics ) )
    {
        console_printf_terminal ("Error in getting TI_GetStatistics!!\n");
        return;
    }

    console_printf_terminal("******************\n");
    console_printf_terminal("Driver Statistics:\n");
    console_printf_terminal("******************\n");

    console_printf_terminal("    dot11CurrentTxRate : %s\n", print_rate(statistics.dot11CurrentTxRate) );
    console_printf_terminal("   dot11CurrentChannel : %d\n", statistics.dot11CurrentChannel );
    console_printf_terminal("     currentMACAddress : %s\n", print_mac_2_str(statistics.currentMACAddress) );
    console_printf_terminal("      dot11DesiredSSID : %s\n", get_ssid_string(&statistics.dot11DesiredSSID) );
    console_printf_terminal("          dot11BSSType : %d\n", statistics.dot11BSSType );
    console_printf_terminal("    AuthenticationMode : %d\n", statistics.AuthenticationMode );
    console_printf_terminal("    bShortPreambleUsed : %d\n", statistics.bShortPreambleUsed );
    console_printf_terminal("          RTSThreshold : %d\n", statistics.RTSThreshold );
    console_printf_terminal("FragmentationThreshold : %d\n", statistics.FragmentationThreshold );
    console_printf_terminal(" bDefaultWEPKeyDefined : %d\n", statistics.bDefaultWEPKeyDefined );
    console_printf_terminal("             WEPStatus : %d\n", statistics.WEPStatus );
    console_printf_terminal("             TxAntenna : %d\n", statistics.TxAntenna );
    console_printf_terminal("             RxAntenna : %d\n", statistics.RxAntenna );
    console_printf_terminal("            TxPowerDbm : %d\n", statistics.TxPowerDbm );
    console_printf_terminal("             PowerMode : %d\n", statistics.PowerMode );
    console_printf_terminal("               RxLevel : %d\n", statistics.RxLevel );

    /**/
    /* status & AP info*/
    /**/
    console_printf_terminal("            dot11State : %d\n", statistics.dot11State );

    /**/
    /* network layer statistics*/
    /**/
    console_printf_terminal("                RecvOk : %d\n", statistics.tiCounters.RecvOk );
    console_printf_terminal("             RecvError : %d\n", statistics.tiCounters.RecvError );
    console_printf_terminal("     DirectedBytesRecv : %d\n", statistics.tiCounters.DirectedBytesRecv );
    console_printf_terminal("    DirectedFramesRecv : %d\n", statistics.tiCounters.DirectedFramesRecv );
    console_printf_terminal("    MulticastBytesRecv : %d\n", statistics.tiCounters.MulticastBytesRecv );
    console_printf_terminal("   MulticastFramesRecv : %d\n", statistics.tiCounters.MulticastFramesRecv );
    console_printf_terminal("    BroadcastBytesRecv : %d\n", statistics.tiCounters.BroadcastBytesRecv );
    console_printf_terminal("   BroadcastFramesRecv : %d\n", statistics.tiCounters.BroadcastFramesRecv );
    console_printf_terminal("             FcsErrors : %d\n", statistics.tiCounters.FcsErrors );
    console_printf_terminal("           BeaconsRecv : %d\n", statistics.tiCounters.BeaconsRecv );
    console_printf_terminal("          AssocRejects : %d\n", statistics.tiCounters.AssocRejects );
    console_printf_terminal("         AssocTimeouts : %d\n", statistics.tiCounters.AssocTimeouts );
    console_printf_terminal("           AuthRejects : %d\n", statistics.tiCounters.AuthRejects );
    console_printf_terminal("          AuthTimeouts : %d\n", statistics.tiCounters.AuthTimeouts );

    /**/
    /* other statistics*/
    /**/
    console_printf_terminal("        dwSecuritySuit : %d\n", statistics.dwSecuritySuit );
    console_printf_terminal("       dwSecurityState : %d\n", statistics.dwSecurityState );
    console_printf_terminal("  dwSecurityAuthStatus : %d\n", statistics.dwSecurityAuthStatus );
    console_printf_terminal("         dwFeatureSuit : %d\n", statistics.dwFeatureSuit );
}

void cmd_show_tx_statistics(ConParm_t parm[], U16 nParms)
{
    TIWLN_TX_STATISTICS statistics;
    UINT32 TxQid;
    UINT32 AverageDelay;
    UINT32 AverageFWDelay;
    UINT32 AverageMacDelay;
    tiINT32 status;

    UNUSED(parm);
    UNUSED(nParms);

    console_printf_terminal("TI_GetTxStatistics(%s, data=%p, size=%d\n", (char*) g_id_adapter, &statistics, sizeof(statistics) );

    /* The first parameter indicates whether to clear the statistics on read: 0 - don't clear, 1 - clear */
    if ( 0 == nParms )
    {
        status = TI_GetTxStatistics( g_id_adapter, &statistics, 0 );
    }
    else
    {
        status = TI_GetTxStatistics( g_id_adapter, &statistics, parm[0].value );
    }

    if( status )
    {
        console_printf_terminal ("Error in getting TI_GetTxStatistics!!\n");
        return;
    }

    console_printf_terminal("*********************\n");
    console_printf_terminal("Tx Queues Statistics:\n");
    console_printf_terminal("*********************\n");

    for (TxQid = 0; TxQid < MAX_NUM_OF_TX_QUEUES; TxQid++)
    {
        console_printf_terminal("\nTx Queue %d:\n", TxQid);
        console_printf_terminal("===========\n");

        console_printf_terminal("  Total Good Frames             : %d\n", statistics.txCounters[TxQid].XmitOk );
        console_printf_terminal("  Unicast Bytes                 : %d\n", statistics.txCounters[TxQid].DirectedBytesXmit );
        console_printf_terminal("  Unicast Frames                : %d\n", statistics.txCounters[TxQid].DirectedFramesXmit );
        console_printf_terminal("  Multicast Bytes               : %d\n", statistics.txCounters[TxQid].MulticastBytesXmit );
        console_printf_terminal("  Multicast Frames              : %d\n", statistics.txCounters[TxQid].MulticastFramesXmit );
        console_printf_terminal("  Broadcast Bytes               : %d\n", statistics.txCounters[TxQid].BroadcastBytesXmit );
        console_printf_terminal("  Broadcast Frames              : %d\n", statistics.txCounters[TxQid].BroadcastFramesXmit );
        console_printf_terminal("  Retry Failures                : %d\n", statistics.txCounters[TxQid].RetryFailCounter );
        console_printf_terminal("  Tx Timeout Failures           : %d\n", statistics.txCounters[TxQid].TxTimeoutCounter );
        console_printf_terminal("  No Link Failures              : %d\n", statistics.txCounters[TxQid].NoLinkCounter );
        console_printf_terminal("  Other Failures                : %d\n", statistics.txCounters[TxQid].OtherFailCounter );
        console_printf_terminal("  Max Consecutive Retry Failures : %d\n\n", statistics.txCounters[TxQid].MaxConsecutiveRetryFail );

        console_printf_terminal("  Retry histogram:\n");
        console_printf_terminal("  ----------------\n\n");
        console_printf_terminal("  Retries: %8d %8d %8d %8d %8d %8d %8d %8d\n", 0, 1, 2, 3, 4, 5, 6, 7);
        console_printf_terminal("  packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n",
                                statistics.txCounters[TxQid].RetryHistogram[ 0 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 1 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 2 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 3 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 4 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 5 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 6 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 7 ]);
        console_printf_terminal("  Retries: %8d %8d %8d %8d %8d %8d %8d %8d\n", 8, 9, 10, 11, 12, 13, 14, 15);
        console_printf_terminal("  packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n",
                                statistics.txCounters[TxQid].RetryHistogram[ 8 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 9 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 10 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 11 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 12 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 13 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 14 ],
                                statistics.txCounters[TxQid].RetryHistogram[ 15 ]);

        if (statistics.txCounters[TxQid].NumPackets)
        {
            AverageDelay = statistics.txCounters[TxQid].SumTotalDelayMs / statistics.txCounters[TxQid].NumPackets;
            AverageFWDelay = statistics.txCounters[TxQid].SumFWDelayUs / statistics.txCounters[TxQid].NumPackets;
            AverageMacDelay = statistics.txCounters[TxQid].SumMacDelayUs / statistics.txCounters[TxQid].NumPackets;
        }
        else
        {
            AverageDelay = 0;
            AverageFWDelay = 0;
            AverageMacDelay = 0;
        }

        console_printf_terminal("  Total Delay ms (average/sum) : %d / %d\n", AverageDelay, statistics.txCounters[TxQid].SumTotalDelayMs);
        console_printf_terminal("  FW Delay us (average/sum) : %d / %d\n", AverageFWDelay, statistics.txCounters[TxQid].SumFWDelayUs);
        console_printf_terminal("  MAC Delay us (average/sum)   : %d / %d\n\n", AverageMacDelay, statistics.txCounters[TxQid].SumMacDelayUs);

        console_printf_terminal("  Delay Ranges [msec]  : Num of packets\n");
        console_printf_terminal("  -------------------  : --------------\n");
        console_printf_terminal("        0   -    1     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_0_TO_1] );
        console_printf_terminal("        1   -   10     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_1_TO_10] );
        console_printf_terminal("       10   -   20     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_10_TO_20] );
        console_printf_terminal("       20   -   40     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_20_TO_40] );
        console_printf_terminal("       40   -   60     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_40_TO_60] );
        console_printf_terminal("       60   -   80     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_60_TO_80] );
        console_printf_terminal("       80   -  100     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_80_TO_100] );
        console_printf_terminal("      100   -  200     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_100_TO_200] );
        console_printf_terminal("        Above 200      : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_ABOVE_200] );
    }
}

void cmd_show_about(ConParm_t parm[], U16 nParms)
{
    TIWLN_VERSION_EX data;

    UNUSED(parm);
    UNUSED(nParms);

    console_printf_terminal("Utility version: %s (%u.%u.%u)\n", SW_VERSION_STR, SW_RELEASE_DAY,
            SW_RELEASE_MONTH, SW_RELEASE_YEAR );
    if( TI_GetDriverVersion(g_id_adapter, &data ) )
        return ;

    console_printf_terminal("Driver version: %u.%u.%u.%u.%u\n", data.DrvVersion.major, data.DrvVersion.minor,
            data.DrvVersion.bugfix, data.DrvVersion.subld, data.DrvVersion.build );
    console_printf_terminal("Firmware version: %u.%u.%u.%u.%u\n", data.FWVersion.major, data.FWVersion.minor,
            data.FWVersion.bugfix, data.FWVersion.subld, data.FWVersion.build );
    console_printf_terminal("Eeprom Version: %u.%u.%u.%u.%u\n", data.HWVersion.major, data.HWVersion.minor,
            data.HWVersion.bugfix, data.HWVersion.subld, data.HWVersion.build );
    console_printf_terminal("Eeprom Version2: %u.%u.%u.%u.%u\n", data.NVVersion.major, data.NVVersion.minor,
            data.NVVersion.bugfix, data.NVVersion.subld, data.HWVersion.build );
}

void cmd_modify_ssid(ConParm_t parm[], U16 nParms)
{
    OS_802_11_SSID ssid = { 0 };
    OS_802_11_MAC_ADDRESS bssid = { 0xff,0xff,0xff,0xff,0xff,0xff };
    char *ssid_str;

    if( nParms == 0 )
    {
        if(!TI_GetCurrentSSID(g_id_adapter, &ssid))
            ssid_str = get_ssid_string(&ssid);
        else
            ssid_str = "<error>";
        console_printf_terminal("SSID: %s\n",  ssid_str );
    }
    else{
        /* Setting the new SSID, BRCS BSSID is set to clean pre-set BSSID */
        TI_SetBSSID(g_id_adapter, &bssid );
        TI_SetSSID(g_id_adapter, (tiUINT8 *) parm[0].value);
}
}

void cmd_modify_channel(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data1 = 0, data = 0;
        if( !TI_GetDesiredChannel( g_id_adapter, &data1) )
            console_printf_terminal("Channel=%d (desired: %d)\n", !TI_GetCurrentChannel(g_id_adapter, &data) ? data : -1, data1 );
    }
    else
        TI_SetDesiredChannel( g_id_adapter, parm[0].value );
}

void cmd_set_power_mode(ConParm_t parm[], U16 nParms)
{
    OS_802_11_POWER_PROFILE mode = 0x12345678;
    if( nParms )
        TI_ConfigPowerManagement (g_id_adapter, parm[0].value );
    else
    {
        if( !TI_GetPowerMode(g_id_adapter, &mode ) )
        {
            console_printf_terminal("Power mode: %d\n", mode );
            print_available_values(power_mode_val);
        }
    }
}

void cmd_set_PowerSave_PowerLevel(ConParm_t parm[], U16 nParms)
{
    OS_802_11_POWER_LEVELS mode;
    if( nParms )
        TI_SetPowerLevelPS (g_id_adapter, parm[0].value );
    else
    {
        if( !TI_GetPowerLevelPS(g_id_adapter, &mode ) )
        {
            console_printf_terminal("Power Level PowerSave: %d\n", mode );
            print_available_values(power_level_val);
        }
    }
}

void cmd_set_Default_PowerLevel(ConParm_t parm[], U16 nParms)
{
    OS_802_11_POWER_LEVELS mode;
    if( nParms )
        TI_SetPowerLevelDefault (g_id_adapter, parm[0].value );
    else
    {
        if( !TI_GetPowerLevelDefault(g_id_adapter, &mode ) )
        {
            console_printf_terminal("Default Power Level: %d\n", mode );
            print_available_values(power_level_val);
        }
    }
}

void cmd_set_DozeModeInAutoPowerLevel(ConParm_t parm[], U16 nParms)
{
	OS_802_11_POWER_PROFILE mode;
    if( nParms )
        TI_SetPowerLevelDozeMode (g_id_adapter, parm[0].value );
    else
    {
		/* set Short or Long Doze. no use of other parameters */
        if( !TI_GetPowerLevelDozeMode(g_id_adapter,&mode ) )
        {
            console_printf_terminal("Doze Mode in Auto Power Level: SHORT_DOZE -  %d LONG_DOZE - %d\n",
				OS_POWER_MODE_SHORT_DOZE,OS_POWER_MODE_LONG_DOZE);
        }
    }
}


void cmd_Beacon_Filter_Set_Desired_State(ConParm_t parm[], U16 nParms)
{
    /*there are two modes : feature ACTIVE & PASSIV ( or NOT ACTIVE )*/
    if( nParms )
    {
        TI_SetBeaconFilterDesiredState(g_id_adapter, parm[0].value );
    }
    else
    {
        console_printf_terminal("Use : 0 =  INACTIVE , 1 = ACTIVE\n" ) ;

    }
}

void cmd_Beacon_Filter_Get_Desired_State(ConParm_t parm[], U16 nParms)
{
    UINT8 desState = FALSE ;

    TI_GetBeaconFilterDesiredState(g_id_adapter, &desState ) ;
    console_printf_terminal("Desired State is %s\n", (desState == FALSE)?"FILTER INACTIVE":"FILTER ACTIVE" );


}



/* scan commands (new from eSTAdk 5.0) */

void init_scan_params(void)
{
    int i,j;

    /* init application scan default params */
    appScanParams.desiredSsid.len = 0;
    appScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    appScanParams.band = RADIO_BAND_2_4_GHZ;
    appScanParams.probeReqNumber = 3;
    appScanParams.probeRequestRate = DRV_RATE_MASK_2_BARKER;
    appScanParams.numOfChannels = 11;
    for ( i = 0; i < 11; i++ )
    {
        for ( j = 0; j < 6; j++ )
        {
            appScanParams.channelEntry[ i ].normalChannelEntry.bssId.addr[ j ] = 0xff;
        }
        appScanParams.channelEntry[ i ].normalChannelEntry.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
        appScanParams.channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes = 0;
        appScanParams.channelEntry[ i ].normalChannelEntry.maxChannelDwellTime = 60000;
        appScanParams.channelEntry[ i ].normalChannelEntry.minChannelDwellTime = 30000;
        appScanParams.channelEntry[ i ].normalChannelEntry.txPowerDbm = MAX_TX_POWER;
        appScanParams.channelEntry[ i ].normalChannelEntry.channel = i + 1;
    }

    /* init default scan policy */
    scanPolicy.normalScanInterval = 10000;
    scanPolicy.deterioratingScanInterval = 5000;
    scanPolicy.maxTrackFailures = 3;
    scanPolicy.BSSListSize = 4;
    scanPolicy.BSSNumberToStartDiscovery = 1;
    scanPolicy.numOfBands = 1;
    scanPolicy.bandScanPolicy[ 0 ].band = RADIO_BAND_2_4_GHZ;
    scanPolicy.bandScanPolicy[ 0 ].rxRSSIThreshold = -80;
    scanPolicy.bandScanPolicy[ 0 ].numOfChannles = 11;
    scanPolicy.bandScanPolicy[ 0 ].numOfChannlesForDiscovery = 3;
    for ( i = 0; i < 11; i++ )
    {
        scanPolicy.bandScanPolicy[ 0 ].channelList[ i ] = i + 1;
    }
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.minChannelDwellTime = 15000;
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_1_BARKER;
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = MAX_TX_POWER;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.minChannelDwellTime = 15000;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_2_BARKER;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = MAX_TX_POWER;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.minChannelDwellTime = 15000;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_5_5_CCK;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = MAX_TX_POWER;
}

void cmd_Scan_Start(ConParm_t parm[], U16 nParms)
{
    TI_StartScan( g_id_adapter, &appScanParams );
    console_printf_terminal("Application scan started.\n");
}

void cmd_Scan_Stop(ConParm_t parm[], U16 nParms)
{
    TI_StopScan( g_id_adapter );
    console_printf_terminal("Application scan stopped.\n");
}

void cmd_Scan_app_global_config(ConParm_t parm[], U16 nParms)
{
    if ( 0 == strcmp( "<empty>", (char*)parm[0].value) )
    {
        appScanParams.desiredSsid.len = 0;
        appScanParams.desiredSsid.ssidString[ 0 ] = '\0';
    }
    else
    {
    appScanParams.desiredSsid.len = strlen((char*)parm[0].value);
    memcpy( &(appScanParams.desiredSsid.ssidString), (char*)parm[0].value, appScanParams.desiredSsid.len );
    }
    appScanParams.scanType = parm[1].value;
    appScanParams.band = parm[2].value;
    appScanParams.probeReqNumber = (UINT8)parm[3].value;
    appScanParams.probeRequestRate = parm[4].value;
#ifdef TI_DBG
    appScanParams.Tid = (UINT8)parm[5].value;
    appScanParams.numOfChannels  = (UINT8)parm[6].value;
#else
    appScanParams.Tid = 0;
    appScanParams.numOfChannels = (UINT8)parm[5].value;
#endif
}

void cmd_Scan_app_channel_config(ConParm_t parm[], U16 nParms)
{
    scan_normalChannelEntry_t* pChannelEntry =
        &(appScanParams.channelEntry[ parm[0].value ].normalChannelEntry);

	if (parm[2].value < parm[3].value)
	{
		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
		return;
	}

    hexStr2MACAddr( (char*)parm[1].value, &(pChannelEntry->bssId) );
    pChannelEntry->maxChannelDwellTime = parm[2].value;
    pChannelEntry->minChannelDwellTime = parm[3].value;
    pChannelEntry->earlyTerminationEvent = parm[4].value;
    pChannelEntry->ETMaxNumOfAPframes = (UINT8)parm[5].value;
    pChannelEntry->txPowerDbm = (UINT8)parm[6].value;
    pChannelEntry->channel = (UINT8)parm[7].value;
}

void cmd_Scan_app_clear(ConParm_t parm[], U16 nParms)
{
    memset( &appScanParams, 0, sizeof(scan_Params_t) );
    console_printf_terminal("Application scan parameters cleared.\n");
}

void cmd_Scan_app_display(ConParm_t parm[], U16 nParms)
{
    int i;
    scan_normalChannelEntry_t* pNormalChannel;
    char bssId[18];

    bssId[17] = '\0';
    console_printf_terminal("Application Scan params:\n");
    console_printf_terminal("SSID: %s, Type: %s\n", appScanParams.desiredSsid.ssidString, scanType2Str[ appScanParams.scanType ].name);
    console_printf_terminal("Band: %s, Number of probe req:%d, probe req. rate:%s\n",
          band2Str[ appScanParams.band ].name, appScanParams.probeReqNumber, rate2StrFunc( appScanParams.probeRequestRate ) );
#ifdef TI_DBG
    console_printf_terminal("Tid :%d\n\n", appScanParams.Tid);
#else
    console_printf_terminal("\n");
#endif
    console_printf_terminal("Channel  BSS ID             Max time  Min time  ET event     ET frame num Power\n");
    console_printf_terminal("-------------------------------------------------------------------------------\n");
    for ( i = 0; i < appScanParams.numOfChannels; i++ )
    {
        pNormalChannel = &(appScanParams.channelEntry[ i ].normalChannelEntry);
        mac2HexStr( &(pNormalChannel->bssId), bssId );
        console_printf_terminal ("%2d       %s  %7d   %7d   %s%3d          %1d\n",
               pNormalChannel->channel, bssId, pNormalChannel->maxChannelDwellTime,
               pNormalChannel->minChannelDwellTime, EtEvent2StrFunc( pNormalChannel->earlyTerminationEvent ),
               pNormalChannel->ETMaxNumOfAPframes, pNormalChannel->txPowerDbm);
    }
    console_printf_terminal("\n");
}

void cmd_Scan_policy_global_config(ConParm_t parm[], U16 nParms)
{
    scanPolicy.normalScanInterval =  parm[ 0 ].value;
    scanPolicy.deterioratingScanInterval = parm[ 1 ].value;
    scanPolicy.maxTrackFailures = (UINT8)(parm[ 2 ].value);
    scanPolicy.BSSListSize = (UINT8)(parm[ 3 ].value);
    scanPolicy.BSSNumberToStartDiscovery = (UINT8)(parm[ 4 ].value);
    scanPolicy.numOfBands = (UINT8)(parm[ 5 ].value);
}

void cmd_Scan_band_global_config(ConParm_t parm[], U16 nParms)
{
    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);

    bandPolicy->band = parm[ 1 ].value;
    bandPolicy->rxRSSIThreshold = (S8)(parm[ 2 ].value);
    bandPolicy->numOfChannlesForDiscovery = (UINT8)(parm[ 3 ].value);
    bandPolicy->numOfChannles = (UINT8)(parm[ 4 ].value);
}

void cmd_Scan_band_channel_config(ConParm_t parm[], U16 nParms)
{
    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);

    bandPolicy->channelList[ parm[ 1 ].value ] = (UINT8)(parm[ 2 ].value);
}

void cmd_Scan_band_track_config(ConParm_t parm[], U16 nParms)
{
    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);

	if (parm[6].value < parm[7].value)
	{
		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
		return;
	}

    bandPolicy->trackingMethod.scanType = parm[ 1 ].value;

    switch (bandPolicy->trackingMethod.scanType)
    {
    case SCAN_TYPE_NORMAL_ACTIVE:
    case SCAN_TYPE_NORMAL_PASSIVE:
        bandPolicy->trackingMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
        bandPolicy->trackingMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
        bandPolicy->trackingMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->trackingMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
        bandPolicy->trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
        bandPolicy->trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(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))
		{
			console_printf_terminal ("ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
			parm[ 4 ].value = 255;
		}
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.triggeringTid = (UINT8)(parm[ 4 ].value);
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
        break;

    case SCAN_TYPE_SPS:
        bandPolicy->trackingMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->trackingMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->trackingMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
        break;

    default:
        bandPolicy->trackingMethod.scanType = SCAN_TYPE_NO_SCAN;
        break;
    }
}

void cmd_Scan_band_discover_config(ConParm_t parm[], U16 nParms)
{
    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);

	if (parm[6].value < parm[7].value)
	{
		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
		return;
	}

    bandPolicy->discoveryMethod.scanType = parm[ 1 ].value;

    switch (bandPolicy->discoveryMethod.scanType)
    {
    case SCAN_TYPE_NORMAL_ACTIVE:
    case SCAN_TYPE_NORMAL_PASSIVE:
        bandPolicy->discoveryMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
        bandPolicy->discoveryMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
        bandPolicy->discoveryMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
        bandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
        bandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(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))
		{
			console_printf_terminal ("ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
			parm[ 4 ].value = 255;
		}
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.triggeringTid = (UINT8)(parm[ 4 ].value);
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
        break;

    case SCAN_TYPE_SPS:
        bandPolicy->discoveryMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->discoveryMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->discoveryMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
        break;

    default:
        bandPolicy->discoveryMethod.scanType = SCAN_TYPE_NO_SCAN;
        break;
    }
}

void cmd_Scan_band_immed_config(ConParm_t parm[], U16 nParms)
{
    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);

	if (parm[6].value < parm[7].value)
	{
		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
		return;
	}

    bandPolicy->immediateScanMethod.scanType = parm[ 1 ].value;

    switch (bandPolicy->immediateScanMethod.scanType)
    {
    case SCAN_TYPE_NORMAL_ACTIVE:
    case SCAN_TYPE_NORMAL_PASSIVE:
        bandPolicy->immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
        bandPolicy->immediateScanMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
        bandPolicy->immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
        bandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
        bandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(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))
		{
			console_printf_terminal ("ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
			parm[ 4 ].value = 255;
		}
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.triggeringTid = (UINT8)(parm[ 4 ].value);
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
        break;

    case SCAN_TYPE_SPS:
        bandPolicy->immediateScanMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
        bandPolicy->immediateScanMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
        bandPolicy->immediateScanMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
        break;

    default:
        bandPolicy->immediateScanMethod.scanType = SCAN_TYPE_NO_SCAN;
        break;
    }
}

void cmd_Scan_policy_display(ConParm_t parm[], U16 nParms)
{
    int i;

    console_printf_terminal("Scan Policy:\n");
    console_printf_terminal("Normal scan interval: %d, deteriorating scan interval: %d\n",
          scanPolicy.normalScanInterval, scanPolicy.deterioratingScanInterval);
    console_printf_terminal("Max track attempt failures: %d\n", scanPolicy.maxTrackFailures);
    console_printf_terminal("BSS list size: %d, number of BSSes to start discovery: %d\n",
          scanPolicy.BSSListSize, scanPolicy.BSSNumberToStartDiscovery);
    console_printf_terminal("Number of configured bands: %d\n", scanPolicy.numOfBands);
    for ( i = 0; i < scanPolicy.numOfBands; i++ )
    {
        cmd_Scan_print_band( i );
    }
}

void cmd_Scan_print_band( int i )
{
    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ i ]);
    int j;

    console_printf_terminal("\nBand: %s\n", band2Str[ bandPolicy->band ].name);
    console_printf_terminal("RSSI Threshold: %d dBm\n", bandPolicy->rxRSSIThreshold);
    console_printf_terminal("Number of channels for each discovery interval: %d\n", bandPolicy->numOfChannlesForDiscovery);
    console_printf_terminal("\nTracking Method:\n");
    cmd_Scan_print_method( &(bandPolicy->trackingMethod) );
    console_printf_terminal("\nDiscovery Method:\n");
    cmd_Scan_print_method( &(bandPolicy->discoveryMethod) );
    console_printf_terminal("\nImmediate Scan Method:\n");
    cmd_Scan_print_method( &(bandPolicy->immediateScanMethod) );
    if ( bandPolicy->numOfChannles > 0 )
    {
        console_printf_terminal("\nChannel list: ");
        for ( j = 0; j < bandPolicy->numOfChannles; j++ )
        {
            console_printf_terminal("%3d ", bandPolicy->channelList[ j ]);
        }
        console_printf_terminal("\n");
    }
    else
        console_printf_terminal("\nNo channels defined.\n");
}

void cmd_Scan_print_method( scan_Method_t* scanMethod )
{
    console_printf_terminal("Scan type: %s\n", scanType2Str[ scanMethod->scanType ].name);
    switch (scanMethod->scanType)
    {
    case SCAN_TYPE_NORMAL_ACTIVE:
    case SCAN_TYPE_NORMAL_PASSIVE:
        cmd_Scan_print_basic_method( &(scanMethod->method.basicMethodParams) );
        break;

    case SCAN_TYPE_TRIGGERED_ACTIVE:
    case SCAN_TYPE_TRIGGERED_PASSIVE:
        cmd_Scan_print_triggered_method( &(scanMethod->method.TidTriggerdMethodParams) );
        break;

    case SCAN_TYPE_SPS:
        cmd_Scan_print_sps_method( &(scanMethod->method.spsMethodParams) );
        break;

    case SCAN_TYPE_NO_SCAN:
        break;
    }
}

void cmd_Scan_print_basic_method( scan_basicMethodParams_t* basicMethodParams )
{
    console_printf_terminal("Max channel dwell time: %d, Min channel dwell time: %d\n",
          basicMethodParams->maxChannelDwellTime, basicMethodParams->minChannelDwellTime);
    console_printf_terminal("ET condition: %s, ET number of frames: %d\n",
          EtEvent2StrFunc( basicMethodParams->earlyTerminationEvent ), basicMethodParams->ETMaxNumberOfApFrames);
    console_printf_terminal("Probe request number: %d, probe request rate: %s, TX power (Dbm/10): %d\n",
          basicMethodParams->probReqParams.numOfProbeReqs, rate2StrFunc( basicMethodParams->probReqParams.bitrate ),
          basicMethodParams->probReqParams.txPowerDbm);
}

void cmd_Scan_print_triggered_method( scan_TidTriggeredMethodParams_t* triggeredMethodParams )
{
    console_printf_terminal("Triggering Tid: %d\n", triggeredMethodParams->triggeringTid);
    cmd_Scan_print_basic_method( &(triggeredMethodParams->basicMethodParams) );
}

void cmd_Scan_print_sps_method( scan_SPSMethodParams_t* spsMethodParams )
{
    console_printf_terminal("ET condition: %s, ET number of frames: %d\n",
          EtEvent2StrFunc( spsMethodParams->earlyTerminationEvent ), spsMethodParams->ETMaxNumberOfApFrames);
    console_printf_terminal("Scan duration: %d\n", spsMethodParams->scanDuration);
}

void cmd_Scan_policy_clear(ConParm_t parm[], U16 nParms)
{
    memset( &scanPolicy, 0, sizeof(scan_Policy_t) );
    console_printf_terminal("Scan policy cleared.\n");
}

void cmd_Scan_policy_store(ConParm_t parm[], U16 nParms)
{
    TI_SetScanPolicy( g_id_adapter, (UINT8*)&scanPolicy, sizeof(scan_Policy_t) );
    console_printf_terminal("Scan policy stored.\n");
}

void cmd_Scan_get_bss_list(ConParm_t parm[], U16 nParms)
{
    bssList_t list;
    int i;

    /* get list */
    if ( (TI_RESULT_OK != TI_GetScanBssList( g_id_adapter, &list )) || (0 == list.numOfEntries) )
    {
        return;
    }

    /* console_printf_terminal list */
    console_printf_terminal("BSS List:\n");
    console_printf_terminal("%-17s  %-7s  %-6s  %-4s  %-10s\n", "BSSID", "Band", "Channel", "RSSI", "Neighbor?");
    console_printf_terminal("-----------------------------------------------------\n");
    for  ( i = 0; i < list.numOfEntries; i++ )
    {

        console_printf_terminal( "%s  %s  %-7d  %-4d  %s\n",
               print_mac_2_str(list.BSSList[ i ].BSSID.addr), band2Str[ list.BSSList[ i ].band ].name,
               list.BSSList[ i ].channel, list.BSSList[ i ].RSSI,
               (TRUE == list.BSSList[ i ].bNeighborAP ? "Yes" : "No") );
    }
}

void cmd_set_dtag_to_ac_mapping_table(ConParm_t parm[], U16 nParms)
{
    int				i;
    acTrfcType_e	dtagToAcTable[MAX_NUM_OF_802_1d_TAGS];

    for (i=0; i<MAX_NUM_OF_802_1d_TAGS; i++)
    {
        dtagToAcTable[i] = (UINT32) parm[i].value;
	}
	console_printf_terminal("Input parameters =%d, %d, %d, %d, %d, %d, %d, %d\n",
                    (UINT32) parm[0].value,
                    (UINT32) parm[1].value,
                    (UINT32) parm[2].value,
                    (UINT32) parm[3].value,
                    (UINT32) parm[4].value,
                    (UINT32) parm[5].value,
                    (UINT32) parm[6].value,
                    (UINT32) parm[7].value);

	if (TI_SetDTagToAcMappingTable(g_id_adapter, dtagToAcTable) == TI_RESULT_OK)
	{
	}
	else
	{
		console_printf_terminal ("Error: could not set tag_ToAcClsfrTable ...\n");
	}
}

void cmd_set_vad(ConParm_t parm[], U16 nParms)
{
	txDataVadTimerParams_t  pVadTimer;

	if (0 == nParms)	// GET operation
	{
		console_printf_terminal("Set VAD: \n");
		console_printf_terminal("    Parm 0 -- 1: ENABLE; 0: DISABLE\n");
		console_printf_terminal("    Parm 1 -- VAD timer duration in ms for enabling action\n");
		if (TI_GetVAD(g_id_adapter, &pVadTimer) == TI_RESULT_OK)
		{

		    console_printf_terminal("Current param values: %d, %d\n",
				 pVadTimer.vadTimerEnabled, pVadTimer.vadTimerDuration);
		}
	}
	else
	{
		pVadTimer.vadTimerEnabled  = (UINT16) parm[0].value;
		pVadTimer.vadTimerDuration = (UINT16) parm[1].value;

		if (pVadTimer.vadTimerEnabled)
		{
			console_printf_terminal("Enabling VAD timer (cycle = %d ms)\n", pVadTimer.vadTimerDuration);
		}
		else
		{
			console_printf_terminal("Disabling VAD timer\n");
		}

		if (TI_SetVAD(g_id_adapter, &pVadTimer) == TI_RESULT_OK)
		{
			console_printf_terminal("Setting VAD is done\n");
		}
	}
}


void cmd_set_qos_params(ConParm_t parm[], U16 nParms)
{
   OS_802_11_QOS_PARAMS pQosParams;

   pQosParams.acID=parm[0].value;
   pQosParams.MaxLifeTime=parm[1].value;
   pQosParams.VoiceDeliveryProtocol=0;
   pQosParams.PSDeliveryProtocol=0;

   if (nParms == 7) /* If the user has input 7 parameters, it means he gave Voice+PS delivery protocol values */
   {
      pQosParams.VoiceDeliveryProtocol=parm[5].value;
      pQosParams.PSDeliveryProtocol=parm[6].value;

      /* If this QOS config was done for a queue OTHER THAN VO, we will zero the DeliveryProtocolPsPoll parameter and notify the user */
      if ((parm[0].value != 3) && (parm[5].value != 0))
         {
            pQosParams.VoiceDeliveryProtocol = 0;
            console_printf_terminal("Since the acID is not VO, resetting VoiceDeliveryProtocol parameter to PS_NONE\n");
         }
      if ((pQosParams.VoiceDeliveryProtocol == 1) && (pQosParams.PSDeliveryProtocol == 1))
      {
            pQosParams.VoiceDeliveryProtocol = 1;
            pQosParams.PSDeliveryProtocol = 0;
            console_printf_terminal("Since the VoiceDeliveryProtocol is PS_POLL, resetting PSDeliveryProtocol to Legacy\n");
      }
   }

   if (TI_SetQosParameters(g_id_adapter, &pQosParams) == TI_RESULT_OK)
   {
      console_printf_terminal("Sent QOS params to driver...\n AC Number=%d \n MaxLifeTime=%d \n DeliveryProtocolPsPoll = %d\n PSDeliveryProtocol = %d\n",
          pQosParams.acID,
          pQosParams.MaxLifeTime,
          pQosParams.VoiceDeliveryProtocol,
          pQosParams.PSDeliveryProtocol);
   }
   else
   {
      console_printf_terminal ("Error: could not set QOS params...\n");
   }
}

void cmd_set_rxTimeOut_params(ConParm_t parm[], U16 nParms)
{
    OS_802_11_QOS_RX_TIMEOUT_PARAMS rxTimeOut;

    rxTimeOut.psPoll = parm[0].value;
    rxTimeOut.UPSD   = parm[1].value;

    if (nParms != 2)
    {
        console_printf_terminal("Please enter Rx Time Out:\n");
        console_printf_terminal("Param 0 - psPoll (0 - 65000)\n");
        console_printf_terminal("Param 1 - UPSD (1 - 65000)\n");
    }
    else
    {
       if (TI_SetQosRxTimeOut(g_id_adapter, &rxTimeOut) == TI_RESULT_OK)
       {
          console_printf_terminal("Sent QOS Rx TimeOut params to driver...\n PsPoll = %d\n UPSD = %d\n",
              rxTimeOut.psPoll,
              rxTimeOut.UPSD);
       }
       else
       {
          console_printf_terminal ("Error: could not set Rx TimeOut..\n");
       }
    }
}


void cmd_enable_rx_data_filters(ConParm_t parm[], U16 nParms)
{
    console_printf_terminal("Enabling Rx data filtering...\n");
    TI_EnableDisableRxDataFilters( g_id_adapter, TRUE );
}


void cmd_disable_rx_data_filters(ConParm_t parm[], U16 nParms)
{
    console_printf_terminal("Disabling Rx data filtering...\n");
    TI_EnableDisableRxDataFilters( g_id_adapter, FALSE );
}


void cmd_get_rx_data_filters_statistics(ConParm_t parm[], U16 nParms)
{
    TIWLAN_DATA_FILTER_STATISTICS statistics;


    console_printf_terminal("Rx data filtering statistics:\n");

    TI_GetRxDataFiltersStatistics( g_id_adapter, &statistics );

    console_printf_terminal("Unmatched packets: %u\n", statistics.UnmatchedPacketsCount);
    console_printf_terminal("Packets matching filter #1: %u\n", statistics.MatchedPacketsCount[0]);
    console_printf_terminal("Packets matching filter #2: %u\n", statistics.MatchedPacketsCount[1]);
    console_printf_terminal("Packets matching filter #3: %u\n", statistics.MatchedPacketsCount[2]);
    console_printf_terminal("Packets matching filter #4: %u\n", statistics.MatchedPacketsCount[3]);
}

void cmd_show_power_consumption_stats(ConParm_t parm[])
{
    PowerConsumptionTimeStat_t statistics;


    TI_GetPowerConsumptionStatistics( g_id_adapter, &statistics );

    console_printf_terminal("\nPower Consumption Statistics:\n");
    console_printf_terminal("-----------------------------\n");
    console_printf_terminal("activeTimeCnt_H: %u\n", statistics.activeTimeCnt_Hi);
    console_printf_terminal("activeTimeCnt_Low: %u\n", statistics.activeTimeCnt_Low);
    console_printf_terminal("elpTimeCnt_Hi: %u\n", statistics.elpTimeCnt_Hi);
    console_printf_terminal("elpTimeCnt_Low: %u\n", statistics.elpTimeCnt_Low);
    console_printf_terminal("powerDownTimeCnt_Hi: %u\n", statistics.powerDownTimeCnt_Hi);
    console_printf_terminal("powerDownTimeCnt_Low: %u\n", statistics.powerDownTimeCnt_Low);

}



static void parse_hex_string(char * pString, tiUINT8 * pBuffer, tiUINT8 * Length)
{
    char ch;
    int iter = 0;

    while ((ch = pString[iter]))
    {
        UINT8 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... */
    *Length = (iter + 1) / 2;
}

static void parse_binary_string(char * pString, tiUINT8 * pBuffer, tiUINT8 * Length)
{
    char ch;
    int iter = 0;

    while ((ch = pString[iter]))
    {
        UINT8 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... */
    *Length = (iter + BIT_TO_BYTE_FACTOR - 1) / BIT_TO_BYTE_FACTOR;
}

void cmd_add_rx_data_filter(ConParm_t parm[], U16 nParms)
{
    tiUINT32 resultCode;
    TIWLAN_DATA_FILTER_REQUEST request;

    char * mask = (char *) parm[1].value;
    char * pattern = (char *) parm[2].value;


    request.Offset = (UINT8) parm[0].value;

    parse_binary_string(mask, request.Mask, &request.MaskLength);
    parse_hex_string(pattern, request.Pattern, &request.PatternLength);

    resultCode = TI_AddRxDataFilter(g_id_adapter, &request);


    console_printf_terminal(resultCode == RX_NO_AVAILABLE_FILTERS ? "Error: There are no available filter slots.\n" :
                            resultCode == RX_FILTER_ALREADY_EXISTS ? "Error: Filter already exists.\n" :
                            resultCode == NOK ? "Error: Could not add the filter.\n" :
                            "Filter added.\n");
}

void cmd_remove_rx_data_filter(ConParm_t parm[], U16 nParms)
{
    tiUINT32 resultCode;
    TIWLAN_DATA_FILTER_REQUEST request;

    char * mask = (char *) parm[1].value;
    char * pattern = (char *) parm[2].value;

    request.Offset = (UINT8) parm[0].value;

    parse_binary_string(mask, request.Mask, &request.MaskLength);
    parse_hex_string(pattern, request.Pattern, &request.PatternLength);

    resultCode = TI_RemoveRxDataFilter(g_id_adapter, &request);

    console_printf_terminal(resultCode == RX_FILTER_DOES_NOT_EXIST ? "Error: Filter was not found.\n" :
                            resultCode == NOK ? "Error: Could not remove the filter, removal request must be identical to add request.\n" :
                            "Filter removed.\n");
}

void cmd_MaxRxLifetime_params(ConParm_t parm[], U16 nParms)
{
    PLT_MIB_t Mib;
    UINT32 Status;
    memset(&Mib, 0, sizeof(Mib));
    Mib.aMib = PLT_MIB_dot11MaxReceiveLifetime;

	if (nParms != 1)
	{
	   console_printf_terminal("Max Rx lifetime: [0 - 4294967295(0xFFFFFFFF)]\n");

	}

	if (nParms == 0) /*Get MaxRxlifetime */
    {
        Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
        if (OK == Status)
  	       console_printf_terminal("MaxRxLifetime = %d\n", Mib.aData.MaxReceiveLifeTime);
    }
    else if (nParms == 1)
    {
        Mib.Length = sizeof(Mib.aData.MaxReceiveLifeTime);
        Mib.aData.MaxReceiveLifeTime = parm[0].value;
        if (OK != TI_PLT_WriteMIB(g_id_adapter, &Mib))
            console_printf_terminal("TI_PLT_WriteMIB failed\n");
    }
}


void cmd_add_tspec(ConParm_t parm[], U16 nParms)
{
   OS_802_11_QOS_TSPEC_PARAMS pTspecParams;
   tiUINT32 resultCode;

   pTspecParams.uUserPriority = parm[0].value;
   pTspecParams.uNominalMSDUsize = parm[1].value;
   pTspecParams.uMeanDataRate = parm[2].value;
   pTspecParams.uMinimumPHYRate = parm[3].value * 1000 * 1000;
   pTspecParams.uSurplusBandwidthAllowance = parm[4].value << 13;
   pTspecParams.uAPSDFlag = parm[5].value;

   resultCode = TI_AddTspec (g_id_adapter,&pTspecParams);

   switch (resultCode)
   {
   case OK:
      console_printf_terminal ("TSpec request sent to driver...\n uUserPriority = %d\n uNominalMSDUsize = %d\n uMeanDataRate = %d\n uMinimumPHYRate = %d\n uSurplusBandwidthAllowance = %d\n uAPSDFlag = %d\n",
               parm[0].value,
               parm[1].value,
               parm[2].value,
               parm[3].value,
               parm[4].value,
               parm[5].value);
      break;
   case TRAFIC_ADM_PENDING:
      console_printf_terminal ("Driver is still waiting for a response of previous request...\n");
      break;
   case AC_ALREADY_IN_USE:
      console_printf_terminal ("Other user priority from the same AC has already used a TSPEC...\n");
      break;
   case NOT_CONNECTED:
      console_printf_terminal ("Not connected to an AP...\n");
      break;
   case NO_QOS_AP:
      console_printf_terminal ("AP does not support QOS...\n");
      break;
   case NOK:
      console_printf_terminal ("Invalid parameter...\n");
      break;
   default:
      console_printf_terminal ("Unknown return value...\n");
      break;
   }

   return;
}

void cmd_get_tspec_params(ConParm_t parm[], U16 nParms)
{
   OS_802_11_QOS_TSPEC_PARAMS pTspecParams;
   tiUINT32 resultCode;

   pTspecParams.uUserPriority = parm[0].value;

   resultCode = TI_GetTspecParameters(g_id_adapter, &pTspecParams);

   switch (resultCode)
   {
   case OK:
      console_printf_terminal ("TSpec parameters retrieved:\nuUserPriority = %d\nuNominalMSDUsize = %d\nuMeanDataRate = %d\nuMinimumPHYRate = %d\nuSurplusBandwidthAllowance = %d\nuUAPSD_Flag = %d\nuMediumTime = %d\n",
               pTspecParams.uUserPriority,
               pTspecParams.uNominalMSDUsize,
               pTspecParams.uMeanDataRate,
               pTspecParams.uMinimumPHYRate,
               pTspecParams.uSurplusBandwidthAllowance,
               pTspecParams.uAPSDFlag,
               pTspecParams.uMediumTime);
      break;
   case USER_PRIORITY_NOT_ADMITTED:
      console_printf_terminal ("User Priority is not admitted...\n");
      break;
   case NOT_CONNECTED:
      console_printf_terminal ("Not connected to an AP...\n");
      break;
   case NO_QOS_AP:
      console_printf_terminal ("AP does not support QOS...\n");
      break;
   case NOK:
      console_printf_terminal ("Invalid parameter...\n");
      break;
   default:
      console_printf_terminal ("Unknown return value...\n");
      break;
   }

   return;
}

void cmd_delete_tspec(ConParm_t parm[], U16 nParms)
{
   OS_802_11_QOS_DELETE_TSPEC_PARAMS pDelTspecParams;
   tiUINT32 resultCode;

   pDelTspecParams.uUserPriority = parm[0].value;
   pDelTspecParams.uReasonCode = parm[1].value;

   resultCode = TI_DeleteTspec(g_id_adapter, &pDelTspecParams);

   switch (resultCode)
   {
   case OK:
      console_printf_terminal ("TSPEC Delete request sent to driver...\n uUserPriority = %d\n uReasonCode = %d\n",
               pDelTspecParams.uUserPriority,
               pDelTspecParams.uReasonCode);
      break;
   case NOT_CONNECTED:
      console_printf_terminal ("Not connected to an AP...\n");
      break;
   case NO_QOS_AP:
      console_printf_terminal ("AP does not support QOS...\n");
      break;
   case NOK:
      console_printf_terminal ("Invalid parameter...\n");
      break;
   default:
      console_printf_terminal ("Unknown return value...\n");
      break;
   }

}

void cmd_get_ap_qos_params(ConParm_t parm[], U16 nParms)
{
   OS_802_11_AC_QOS_PARAMS pACQosParams;
   int i = 0;
   tiUINT32 resultCode;

   pACQosParams.uAC = i;
   /* Read AC 0 parameters - just to check if connected to QOS AP etc */
   resultCode = TI_GetAPQosParameters(g_id_adapter, &pACQosParams);

   switch (resultCode)
   {
   case OK:
   console_printf_terminal ("AP QOS Parameters:\n");
         console_printf_terminal ("+----+-------------+----------+-----------+-----------+-----------+\n");
         console_printf_terminal ("| AC | AdmCtrlFlag |   AIFS   |   CwMin   |   CwMax   | TXOPLimit |\n");
         console_printf_terminal ("+----+-------------+----------+-----------+-----------+-----------+\n");


   for (i=0; i<4; i++)
      {
         pACQosParams.uAC = i;
         resultCode = TI_GetAPQosParameters(g_id_adapter, &pACQosParams);

               console_printf_terminal ("| %2d | %11d | %8d | %9d | %9d | %9d |\n",i,
               pACQosParams.uAssocAdmissionCtrlFlag,
               pACQosParams.uAIFS,
               pACQosParams.uCwMin,
               pACQosParams.uCwMax,
               pACQosParams.uTXOPLimit);
      }

         console_printf_terminal ("+----+-------------+----------+-----------+-----------+-----------+\n");
      break;
   case NOT_CONNECTED:
      console_printf_terminal ("Not connected to an AP...\n");
      break;
   case NO_QOS_AP:
      console_printf_terminal ("AP does not support QOS...\n");
      break;
   case NOK:
      console_printf_terminal ("Invalid parameter...\n");
      break;
   default:
      console_printf_terminal ("Unknown return value...\n");
      break;
   }

}

void cmd_get_ap_qos_capabilities(ConParm_t parm[], U16 nParms)
{
   OS_802_11_AP_QOS_CAPABILITIES_PARAMS pAPQosCapabiltiesParams;
   tiUINT32 resultCode;

   resultCode = TI_GetAPQosCapabilitesParameters(g_id_adapter, &pAPQosCapabiltiesParams);

   switch (resultCode)
   {
   case TI_RESULT_OK:
      console_printf_terminal ("AP Qos Capabilities:\n QOSFlag = %d\n APSDFlag = %d\n",pAPQosCapabiltiesParams.uQOSFlag,pAPQosCapabiltiesParams.uAPSDFlag);
      break;
   case NOT_CONNECTED:
      console_printf_terminal ("Not connected to an AP...\n");
      break;
   case NO_QOS_AP:
      console_printf_terminal ("AP does not support QOS...\n");
      break;
   default:
      console_printf_terminal ("Unknown return value...\n");
      break;
   }

   return;
}

void cmd_get_ac_status(ConParm_t parm[], U16 nParms)
{
   OS_802_11_AC_UPSD_STATUS_PARAMS pAcStatusParams;
   tiUINT32 resultCode;

   pAcStatusParams.uAC = parm[0].value;

   resultCode = TI_GetCurrentACStatus(g_id_adapter, &pAcStatusParams);

   switch (resultCode)
   {
   case TI_RESULT_OK:
      console_printf_terminal ("AC %d Status:\nCurrentUAPSDStatus = %d (0=PS_POLL,1=UPSD,2=PS_NONE)\nCurrentAdmissionStatus = %d(0=NOT_ADMITED,1=WAIT,2=ADMITED)\n",
               pAcStatusParams.uAC,
               pAcStatusParams.uCurrentUAPSDStatus,
               pAcStatusParams.pCurrentAdmissionStatus);
      break;
   case NOT_CONNECTED:
      console_printf_terminal ("Not connected to an AP...\n");
      break;
   case NO_QOS_AP:
      console_printf_terminal ("AP does not support QOS...\n");
      break;
   case NOK:
      console_printf_terminal ("Invalid parameters...\n");
      break;
   default:
      console_printf_terminal ("Unknown return value...\n");
      break;
   }

}

void cmd_get_desired_ps_mode(ConParm_t parm[], U16 nParms)
{
   OS_802_11_QOS_DESIRED_PS_MODE pDesiredPsMode;
   tiUINT32 resultCode;

   resultCode = TI_GetDesiredPsMode(g_id_adapter, &pDesiredPsMode);

   switch (resultCode)
   {
   case TI_RESULT_OK:
      console_printf_terminal ("\n\
Desired PS Mode (0=PS_POLL, 1=UPSD, 2=PS_NONE):\n\
===============================================\n\
General Desired Ps Mode  =  %d\n\
 BE_AC  Desired Ps Mode  =  %d\n\
 BK_AC  Desired Ps Mode  =  %d\n\
 VI_AC  Desired Ps Mode  =  %d\n\
 VO_AC  Desired Ps Mode  =  %d\n",
              pDesiredPsMode.uDesiredPsMode,
              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BE],
              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BK],
              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VI],
              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VO]);

      break;
   case NOK:
      console_printf_terminal ("Invalid parameters...\n");
      break;
   default:
      console_printf_terminal ("Unknown return value...\n");
      break;
   }
}



void cmd_medium_usage_threshold(ConParm_t parm[], U16 nParms)
{
   OS_802_11_THRESHOLD_CROSS_PARAMS pThresholdCrossParams;
   tiUINT32 resultCode;

   if (nParms == 3) /* If user supplied 3 parameters - this is a SET operation */
   {
       pThresholdCrossParams.uAC = parm[0].value;
       pThresholdCrossParams.uHighThreshold = parm[1].value;
       pThresholdCrossParams.uLowThreshold = parm[2].value;

      if (pThresholdCrossParams.uLowThreshold > pThresholdCrossParams.uHighThreshold)
      {
         console_printf_terminal ("Low threshold cannot be higher than the High threshold...Aborting...\n");
      }
      else
      {
           resultCode = TI_SetMediumUsageThreshold(g_id_adapter, &pThresholdCrossParams);
           if (resultCode == TI_RESULT_OK)
           {
               console_printf_terminal ("Medium usage threshold for AC %d has been set to:\n LowThreshold = %d\n HighThreshold = %d\n",
               pThresholdCrossParams.uAC,
               pThresholdCrossParams.uLowThreshold,
               pThresholdCrossParams.uHighThreshold);
           }
           else
           {
               console_printf_terminal ("Error...\n");
           }
      }

   }
   else if (nParms == 1) /* Only 1 parameter means a GET operation */
   {
      pThresholdCrossParams.uAC = parm[0].value;
      pThresholdCrossParams.uLowThreshold = 0;
      pThresholdCrossParams.uHighThreshold = 0;

      resultCode = TI_GetMediumUsageThreshold(g_id_adapter, &pThresholdCrossParams);

      console_printf_terminal ("Medium usage threshold for AC %d:\n LowThreshold = %d\n HighThreshold = %d\n",
          pThresholdCrossParams.uAC,
          pThresholdCrossParams.uLowThreshold,
          pThresholdCrossParams.uHighThreshold);
   }

}

void cmd_phy_rate_threshold(ConParm_t parm[], U16 nParms)
{
   OS_802_11_THRESHOLD_CROSS_PARAMS pThresholdCrossParams;
   tiUINT32 resultCode;

   if (nParms == 3) /* If user supplied 3 parameters - this is a SET operation */
   {
       if ((is_value_rate(parm[1].value) == FALSE) || (is_value_rate(parm[2].value) == FALSE))
       {
          console_printf_terminal ("Invalid rate - PHY rate valid values are: 1,2,5,6,9,11,12,18,24,36,48,54\n");
          return;
       }

       pThresholdCrossParams.uAC = parm[0].value;
       pThresholdCrossParams.uHighThreshold = parm[1].value;
       pThresholdCrossParams.uLowThreshold = parm[2].value;

       if (pThresholdCrossParams.uLowThreshold > pThresholdCrossParams.uHighThreshold)
       {
          console_printf_terminal ("Low threshold cannot be higher than the High threshold...Aborting...\n");
       }
       else
       {

           resultCode = TI_SetPhyRateThreshold(g_id_adapter, &pThresholdCrossParams);

           if (resultCode == TI_RESULT_OK)
           {
              console_printf_terminal ("PHY rate threshold for AC %d has been set to:\n LowThreshold = %d\n HighThreshold = %d\n",
                       pThresholdCrossParams.uAC,
                       pThresholdCrossParams.uLowThreshold,
                       pThresholdCrossParams.uHighThreshold);
           }
           else
           {
              console_printf_terminal ("Error...\n");
           }
       }
   }
   else if (nParms == 1)
   {
      pThresholdCrossParams.uAC = parm[0].value;
      pThresholdCrossParams.uLowThreshold = 0;
      pThresholdCrossParams.uHighThreshold = 0;

      resultCode = TI_GetPhyRateThreshold(g_id_adapter, &pThresholdCrossParams);

      console_printf_terminal ("PHY rate threshold for AC %d:\n",pThresholdCrossParams.uAC);
      console_printf_terminal ("LowThreshold = %s\n",print_rate((rate_e) pThresholdCrossParams.uLowThreshold));
      console_printf_terminal ("HighThreshold = %s\n",print_rate((rate_e) pThresholdCrossParams.uHighThreshold));
   }

}

void cmd_traffic_intensity_threshold(ConParm_t parm[], U16 nParms)
{
   OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS pTrafficIntensityThresholds;
   tiUINT32 resultCode;

   if (nParms == 3)
   {
      pTrafficIntensityThresholds.uHighThreshold = parm[0].value;
      pTrafficIntensityThresholds.uLowThreshold = parm[1].value;
      pTrafficIntensityThresholds.TestInterval = parm[2].value;

      if (pTrafficIntensityThresholds.uLowThreshold >= pTrafficIntensityThresholds.uHighThreshold)
      {
         console_printf_terminal ("Error: low threshold equal or greater than the high threshold...aborting...\n");
      }

      resultCode = TI_SetTrafficIntensityThresholds (g_id_adapter, &pTrafficIntensityThresholds);

      if (resultCode == TI_RESULT_OK)
      {
         console_printf_terminal ("Successfully set traffic intensity thresholds...\n");

      }
      else
      {
         console_printf_terminal ("Error: result code = %d\n",resultCode);
      }
   }
   else if (nParms == 0)
   {
      resultCode = TI_GetTrafficIntensityThresholds (g_id_adapter, &pTrafficIntensityThresholds);

      if (resultCode == TI_RESULT_OK)
      {
         console_printf_terminal ("Traffic intensity thresholds :\n HighThreshold = %d\n LowThreshold = %d\n TestInterval = %d\n",
                  pTrafficIntensityThresholds.uHighThreshold,
                  pTrafficIntensityThresholds.uLowThreshold,
                  pTrafficIntensityThresholds.TestInterval);
      }
      else
      {
         console_printf_terminal ("Error: result code = %d\n",resultCode);
      }

   }

}

void cmd_enable_traffic_events(ConParm_t parm[], U16 nParms)
{
   TI_ToggleTrafficIntensityEvents (g_id_adapter, (tiUINT32)TRUE);
   console_printf_terminal ("Traffic intensity thresholds enabled...\n");
}

void cmd_disable_traffic_events(ConParm_t parm[], U16 nParms)
{
   TI_ToggleTrafficIntensityEvents (g_id_adapter, (tiUINT32)FALSE);
   console_printf_terminal ("Traffic intensity thresholds disabled...\n");
}

void cmd_config_tx_classifier(ConParm_t parm[], U16 nParms)
{
    NWIF_CLSFR_ENTRY inParamsBuff[CLI_NUM_OF_TX_CLASFR_CON];

    UINT32 inParamsBuffLen = 0;
    UINT8 i,ic,iv=0;

    for( ic=0,iv=0; ic<CLI_NUM_OF_TX_CLASFR_CON; ic++)
    {
        inParamsBuff[ic].port = (UINT16 )parm[iv].value;
        iv++;
        inParamsBuff[ic].pri = (UINT16 )parm[iv].value;
        iv++;
        inParamsBuff[ic].ip = 0;


        inParamsBuffLen += sizeof(NWIF_CLSFR_ENTRY);

    }
    for( i=0; i<4; i++,iv++)
    {
        for(ic=0;ic<CLI_NUM_OF_TX_CLASFR_CON;ic++)
        {
            inParamsBuff[ic].ip |= parm[iv].value << i * 8;
        }
    }
}

void cmd_remove_clsfr_entry (ConParm_t parm[], U16 uParms)
{
    clsfr_tableEntry_t newUserTableEntry;
    int i;
    clsfrTypeAndSupport ClsfrType;
    tiINT32 res;

    TI_GetClsfrType(g_id_adapter, &ClsfrType );

    /* Possibly needs to be removed if we want to keep this routine working for old classifier as well */
    if (ClsfrType.oldVersionSupport == TRUE)
    {
      console_printf_terminal ("Old classifier support detected...Remove action disabled (use old classifier config)\n");
      return;
    }

    if (uParms >=2)
        newUserTableEntry.DTag = (tiUINT8) parm[1].value;

    switch(parm[0].value)
    {
        case D_TAG_CLSFR:
            console_printf_terminal("Cannot remove D_TAG classifier entry!\n");
            return;
        break;
        case DSCP_CLSFR:
            if (uParms != 3)
            {
                console_printf_terminal("DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n");
                return;
            }
            newUserTableEntry.Dscp.CodePoint = (tiUINT8) parm[2].value;
            console_printf_terminal ("Removing DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint);
        break;
        case PORT_CLSFR:
            if (uParms != 3)
            {
                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters(too many?)\n");
                return;
            }
            newUserTableEntry.Dscp.DstPortNum = (tiUINT16) parm[2].value;
            console_printf_terminal ("Removing PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum);
        break;
        case IPPORT_CLSFR:
            if (uParms != 7)
            {
                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters\n");
                return;
            }
            newUserTableEntry.Dscp.DstIPPort.DstPortNum = (tiUINT16) parm[2].value;
            newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0;
            for(i=0; i<4; i++)
                {
                    newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8;
                }
            console_printf_terminal ("Removing IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n",
                    newUserTableEntry.DTag,
                    newUserTableEntry.Dscp.DstIPPort.DstPortNum,
                    (int)parm[3].value,(int)parm[4].value,(int)parm[5].value,(int)parm[6].value);
            break;
        default:
            console_printf_terminal("Unknown Classifier Type - Command aborted!\n");
            return;
        break;
    }

    res = TI_RemoveClassifierEntry(g_id_adapter, &newUserTableEntry);
    if (res)
    {
       console_printf_terminal ("Failed to remove classifier entry...return code = %d\n",res);
    }

}

void cmd_insert_clsfr_entry (ConParm_t parm[], U16 uParms)
{
    clsfr_tableEntry_t newUserTableEntry;
    int i;
    clsfrTypeAndSupport ClsfrType;
    tiINT32 res;

    TI_GetClsfrType(g_id_adapter, &ClsfrType );

    if (ClsfrType.oldVersionSupport == TRUE)
    {
      console_printf_terminal ("Old classifier support detected...Insert action disabled (use old classifier config)\n");
      return;
    }

    if (uParms >=2)
        newUserTableEntry.DTag = (UINT8) parm[1].value;

    switch(parm[0].value)
    {
        case D_TAG_CLSFR:
            console_printf_terminal("Cannot insert D_TAG classifier entry!\n");
            return;
        break;
        case DSCP_CLSFR:
            if (uParms != 3)
            {
                console_printf_terminal("DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n");
                return;
            }
            newUserTableEntry.Dscp.CodePoint = (UINT8) parm[2].value;
            console_printf_terminal ("Inserting new DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint);
        break;
        case PORT_CLSFR:
            if (uParms != 3)
            {
                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters(too many?)\n");
                return;
            }
            newUserTableEntry.Dscp.DstPortNum = (UINT16) parm[2].value;
            console_printf_terminal ("Inserting new PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum);
        break;
        case IPPORT_CLSFR:
            if (uParms != 7)
            {
                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters\n");
                return;
            }
            newUserTableEntry.Dscp.DstIPPort.DstPortNum = (UINT16) parm[2].value;
            newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0;
            for(i=0; i<4; i++)
                {
                    newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8;
                }
            console_printf_terminal ("Inserting new IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n",
                    newUserTableEntry.DTag,
                    newUserTableEntry.Dscp.DstIPPort.DstPortNum,
                    (int)parm[3].value,(int)parm[4].value,(int)parm[5].value,(int)parm[6].value);
            break;
        default:
            console_printf_terminal("Unknown Classifier Type - Command aborted!\n");
            return;
        break;
    }

    res = TI_ConfigTxClassifier(g_id_adapter, sizeof(clsfr_tableEntry_t), (UINT8 *)&newUserTableEntry);
    if (res)
    {
       console_printf_terminal ("Failed to insert new classifier entry...return code = %d\n",res);
    }

}

void cmd_poll_ap_packets(ConParm_t parm[], U16 nParms)
{
   if (nParms == 0)
   {
   TI_PollApPackets (g_id_adapter);
   console_printf_terminal ("Poll AP packets cmd sent to driver...\n");
}
   else if (nParms == 1)
   {
      TI_PollApPacketsFromAC (g_id_adapter,parm[0].value);
      console_printf_terminal ("Poll AP packets (From AC %d) cmd sent to driver...\n",(int)parm[0].value);
   }

}

void cmd_modify_rate(ConParm_t parm[], U16 nParms)
{
    tiUINT32 data = 0, data1 = 0;

    if( !TI_GetDesiredRate(g_id_adapter, &data1 ) )
    {
        TI_GetCurrentRate(g_id_adapter, &data );

        console_printf_terminal("Rate: %s", print_rate(data));
        console_printf_terminal(", desired rate: %s\n", print_rate(data1));
    }
}


#if 0    /* not in use*/
void cmd_net_current_regdomain(ConParm_t parm[], U16 nParms)
{
    UNUSED(nParms);
    UNUSED(parm);

    console_printf_terminal("not implemented...\n");
}

 static named_value_t network_type_name[] = {
     { os802_11FH,                     "FH" } ,
     { os802_11DS,                     "DS" } ,
     { os802_11OFDM5,                  "OFDM5" } ,
     { os802_11OFDM24,                 "OFDM24" } ,
     { os802_11OFDM24_AND_5,           "OFDM24_AND_5" } ,
     { os802_11NetworkTypeMax,         "NetworkTypeMax" }
 };

void cmd_net_network_in_use(ConParm_t parm[], U16 nParms)
{
    OS_802_11_NETWORK_TYPE data;
    if( !nParms )
    {
        if( !TI_GetNetworkTypeInUse(g_id_adapter, &data ) )
        {
            print_available_values(network_type_name);

             console_printf_terminal("Cur.network: %d\n", data );
        }
    }
    else
        TI_SetNetworkTypeInUse(g_id_adapter, parm[0].value );
}
#endif /* if 0*/

void cmd_show_tx_power_level_table(ConParm_t parm[], U16 nParms)
{
    TIWLAN_POWER_LEVEL_TABLE powerTable;
	int i;

    if( !TI_GetTxPowerLevel(g_id_adapter, (tiCHAR*)&powerTable) )
	{
        console_printf_terminal("Power level table (Dbm/10)\n");
		for ( i = 0 ; i < TI_NUM_OF_SUB_BANDS ; i++)
		{
			console_printf_terminal("sub-band %i: %d %d %d %d\n", i,
			powerTable.uTxPower[i][0],
			powerTable.uTxPower[i][1],
			powerTable.uTxPower[i][2],
			powerTable.uTxPower[i][3]);
		}
	}
    else
	{
        console_printf_terminal("Tx Power level table ERROR !!!\n");
	}
}
void cmd_tx_power_dbm(ConParm_t parm[], U16 nParms)
{
    tiCHAR dummyData = 0;

	if (nParms == 0)
	{
		if( !TI_GetTxPowerDbm(g_id_adapter, &dummyData))
		{
			console_printf_terminal("Tx Power (Dbm/10) = %d\n", dummyData);
		}
	}
    else
    {
        if (parm[0].value > MAX_TX_POWER)
        {
            console_printf_terminal("Hey !!! You should use values between %d and %d\n", MIN_TX_POWER, MAX_TX_POWER);
            return;
        }
        /* use U8 cast to fix compile warning */
        if(! TI_SetTxPowerDbm(g_id_adapter, (U8)parm[0].value) )
        {
            console_printf_terminal("Set Tx Power in DBM/10 = %d\n", parm[0].value);
        }
    }
}


void cmd_enableDisable_802_11d(ConParm_t parm[], U16 nParms)
{
    UINT8 data = 0;
    tiINT32 result;

    result = TI_Get_802_11d(g_id_adapter, &data );
    if ( nParms == 0 )
    {
        if( result ==  TI_RESULT_OK)
        {
            console_printf_terminal("802_11d status=%d\n", data );
        }
    }
    else
    {
        result = TI_EnableDisable_802_11d(g_id_adapter, (UINT8) parm[0].value);
        if ((result != TI_RESULT_OK) && (!parm[0].value))
        {
            result = TI_Get_802_11h(g_id_adapter, &data );
            if (data)
            {
                console_printf_terminal("802_11d cannot be disabled while 802_11h is enabled!!\n" );
            }
        }
        else
        {
            console_printf_terminal("802_11d status is updated to =%d\n", parm[0].value );
        }

    }


}

void cmd_enableDisable_802_11h(ConParm_t parm[], U16 nParms)
{
    UINT8 data = 0;
    tiINT32 result;

    result = TI_Get_802_11h(g_id_adapter, &data );
    if( nParms == 0 )
    {
        if( result ==  TI_RESULT_OK)
        {
            console_printf_terminal("802_11h status=%d\n", data );
        }
    }
    else
    {
        TI_EnableDisable_802_11h(g_id_adapter, (UINT8) parm[0].value);
        if (parm[0].value)
        {
            console_printf_terminal("802_11h enables automatically 802_11d!!\n" );
        }

        console_printf_terminal("802_11h status is updated to =%d\n", parm[0].value );

    }


}

void cmd_d_Country_2_4Ie(ConParm_t parm[], U16 nParms)
{
    tiINT32 result;

    if( nParms == 0 )
    {
        UINT8   countryString[COUNTRY_STRING_LEN+1];
        result = TI_Get_countryIeFor2_4_Ghz(g_id_adapter, (UINT8**)&countryString );
        if( result ==  TI_RESULT_OK)
        {
            countryString[COUNTRY_STRING_LEN] = '\0';
            if (countryString[0] == '\0')
            {
                console_printf_terminal("802_11d Country for 2.4 GHz is not found\n");
            }
            else
            {
                console_printf_terminal("802_11d Country for 2.4 GHz is %s \n", countryString );
            }

        }
    }
    else
    {
        country_t countryWorld;

        countryWorld.elementId = COUNTRY_IE_ID;
        countryWorld.len = 6;
        memcpy( countryWorld.countryIE.CountryString,"GB ", 3);
        countryWorld.countryIE.tripletChannels[0].firstChannelNumber = 1;
        countryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 23;
        countryWorld.countryIE.tripletChannels[0].numberOfChannels = 11;
        console_printf_terminal("802_11d Start Setting GB Country for 2.4 GHz \n");

        result = TI_Set_countryIeFor2_4_Ghz(g_id_adapter, countryWorld);

        console_printf_terminal("802_11d Setting GB Country for 2.4 GHz, result=%d\n", result);

    }


}

void cmd_d_Country_5Ie(ConParm_t parm[], U16 nParms)
{
    tiINT32 result;

    if( nParms == 0 )
    {
        UINT8   countryString[COUNTRY_STRING_LEN+1];
        result = TI_Get_countryIeFor5_Ghz(g_id_adapter, (UINT8**)&countryString );
        if( result ==  TI_RESULT_OK)
        {
            countryString[COUNTRY_STRING_LEN] = '\0';
            if (countryString[0] == '\0')
            {
                console_printf_terminal("802_11d Country for 5 GHz is not found\n");
            }
            else
            {
                console_printf_terminal("802_11d Country for 5 GHz is %s\n", countryString );
            }
        }
    }
    else
    {
        country_t countryWorld;

        countryWorld.elementId = COUNTRY_IE_ID;
        countryWorld.len = 6;
        memcpy( countryWorld.countryIE.CountryString,"US ", 3);
        countryWorld.countryIE.tripletChannels[0].firstChannelNumber = 36;
        countryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 16;
        countryWorld.countryIE.tripletChannels[0].numberOfChannels = 8;
        result = TI_Set_countryIeFor5_Ghz(g_id_adapter, countryWorld);

        console_printf_terminal("802_11d Setting US Country for 5 GHz, result=%d\n", result);

    }

}

void cmd_DFS_range(ConParm_t parm[], U16 nParms)
{
    tiINT32 result;
    DFS_ChannelRange_t DFS_ChannelRange;

    if( nParms == 0 )
    {

        result = TI_Get_minMaxDfsChannels(g_id_adapter, &DFS_ChannelRange );
        if( result ==  TI_RESULT_OK)
        {
            console_printf_terminal("DFS min channel is %d, DFS max channel is %d\n",
                                    DFS_ChannelRange.minDFS_channelNum, DFS_ChannelRange.maxDFS_channelNum);
        }
    }
    else
    {
        DFS_ChannelRange.minDFS_channelNum = (UINT16) parm[0].value;
        DFS_ChannelRange.maxDFS_channelNum = (UINT16) parm[1].value;

        console_printf_terminal("Given params: min channel %d, DFS max channel %d\n",
                                parm[0].value, parm[1].value);

        result = TI_Set_minMaxDfsChannels(g_id_adapter, DFS_ChannelRange);
        if (result ==  TI_RESULT_OK)
        {
            console_printf_terminal("Setting DFS min channel %d, DFS max channel %d\n",
                                    DFS_ChannelRange.minDFS_channelNum, DFS_ChannelRange.maxDFS_channelNum);
        }
        else
        {
            console_printf_terminal("Setting DFS min channel %d, DFS max channel %d - FAILED !!\n",
                                    DFS_ChannelRange.minDFS_channelNum, DFS_ChannelRange.maxDFS_channelNum);
        }
    }

}

#if 0
void cmd_modify_tx_power_value(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data = 1234;
        if( !TI_GetTxPowerValue(g_id_adapter, &data) )
            console_printf_terminal(  "Tx Power val = %ld\n", data);
    }
    else
        TI_SetTxPowerValue(g_id_adapter, parm[0].value);
}
#endif

void cmd_show_regdomain_table(ConParm_t parm[], U16 nParms)
{
    UNUSED(nParms);
    UNUSED(parm);
    console_printf_terminal(  "not implemented ....\n");
}

void cmd_modify_4x_state(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiBOOL data = FALSE;
        if( !TI_Get4XState(g_id_adapter, &data ) )
            console_printf_terminal("4x state=%s\n", data ? "True" : "False" );
    }
    else    /* param <read-only!!> */
        TI_Set4XState(g_id_adapter, (BOOL) parm[0].value);
}

static named_value_t BSS_type[] =
{
    { os802_11IBSS,                  "AD-Hoc" },
    { os802_11Infrastructure,        "Infr." },
    { os802_11AutoUnknown,           "Auto" },
/*    { os802_11HighSpeedIBSS,         "HighSpeedIBSS" },*/
/*    { os802_11InfrastructureMax,     "Max" }*/
};

void cmd_modify_bss_type(ConParm_t parm[], U16 nParms)
{
    OS_802_11_NETWORK_MODE data = 0;     //TRS:MEB use correct datatype to avoid compiler warning
    if( nParms == 0 )
    {
        if( !TI_GetBSSType(g_id_adapter, &data ) )
        {
            print_available_values(BSS_type);

            console_printf_terminal("Current mode=%d\n", data );
        }
    }
    else    /* param <read-only!!> */
        TI_SetBSSType(g_id_adapter, (BOOL) parm[0].value);
}

void cmd_get_driver_state(ConParm_t parm[], U16 nParms)
{
   static char stateDesc[6][100] =
{
    "DRIVER_STATE_IDLE",
    "DRIVER_STATE_SCANNING",
    "DRIVER_STATE_SELECTING",
    "DRIVER_STATE_CONNECTING",
    "DRIVER_STATE_CONNECTED",
    "DRIVER_STATE_DISCONNECTED",
};
   driverState_e myState;

   TI_GetDriverState (g_id_adapter, &myState);
   console_printf_terminal("Driver state is %s\n", stateDesc[(UINT8)myState]);
}

void cmd_modify_ext_rates_ie(ConParm_t parm[], U16 nParms)
{
    static named_value_t ExtRatesIE[] =
    {
        { DRAFT_5_AND_EARLIER,  "5_AND_EARLIER" },
        { DRAFT_6_AND_LATER,    "6_AND_LATER" }
    };
    if( nParms == 0 )
    {
        tiUINT32 data = 1122;
        if( !TI_GetExtRatesIE(g_id_adapter, &data ) )
        {
            print_available_values(ExtRatesIE);
            console_printf_terminal("ExtRatesIE=%u\n", data  );
        }
    }
    else
        TI_SetExtRatesIE(g_id_adapter, (tiUINT32) parm[0].value);
}


/*will return RSSI*/
void cmd_get_rsii_level(ConParm_t parm[], U16 nParms)
{
   tiINT32 rssi ;
   TI_GetRSSI(g_id_adapter, &rssi);
   console_printf_terminal("\n Current RSSI : %d\n" ,rssi)  ; // TRS:WDK - add return
}


/*will return SNR ratio*/
void cmd_get_snr_ratio(ConParm_t parm[], U16 nParms)
{
   tiUINT32 snr ;
   TI_GetSNR(g_id_adapter, &snr);
   console_printf_terminal("\n Current SNR ratio : %d\n" ,snr)  ;  // TRS:WDK - add return
}

void cmd_modify_frag_threshold(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data = 0xfefefefe;
        if( !TI_GetFragmentThreshold(g_id_adapter, &data ) )
            console_printf_terminal("Frag. threshold=%d\n", data );
    }
    else
        TI_SetFragmentThreshold(g_id_adapter, parm[0].value);
}

void cmd_modify_short_slot(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data = 0xfefefefe;
        if( !TI_GetShortSlot(g_id_adapter, &data ) )
            console_printf_terminal("Short slot=%d\n", data );
    }
    else
        TI_SetShortSlot(g_id_adapter, parm[0].value);
}

void cmd_modify_rts_threshold(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data = 0xfefefefe;
        if( !TI_GetRTSThreshold( g_id_adapter, &data) )
            console_printf_terminal("RTSThreshold=%d\n", data );
    }
    else
        TI_SetRTSThreshold(g_id_adapter, parm[0].value);
}

void cmd_modify_preamble(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data = 0xfefefefe;
        if( !TI_GetShortPreamble( g_id_adapter, &data) )
            console_printf_terminal("ShortPreamble=%d\n", data );
    }
    else
        TI_SetShortPreamble(g_id_adapter, parm[0].value);
}

void cmd_modify_antenna_diversity(ConParm_t parm[], U16 nParms)
{
    TIWLAN_ANT_DIVERSITY antennaDiversityOptions;

    antennaDiversityOptions.enableRxDiversity = (UINT8)parm[0].value;
    antennaDiversityOptions.rxSelectedAntenna = (UINT8)parm[1].value;
    antennaDiversityOptions.enableTxDiversity = (UINT8)parm[2].value;
    antennaDiversityOptions.txSelectedAntenna = (UINT8)parm[3].value;
    antennaDiversityOptions.rxTxSharedAnts = (UINT8)parm[4].value;
    TI_SetAntennaDiversityParams(g_id_adapter, &antennaDiversityOptions);
    console_printf_terminal("Antenna diversity parameters sent.\n");
}

void cmd_modify_short_retry(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data = 0xfefefefe;
        if( !TI_GetShortRetry( g_id_adapter, &data) )
            console_printf_terminal("ShortRetry=%d\n", data );
    }
    else
        TI_SetShortRetry(g_id_adapter, parm[0].value);
}

void cmd_modify_long_retry(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        tiUINT32 data = 0xfefefefe;
        if( !TI_GetLongRetry( g_id_adapter, &data) )
            console_printf_terminal("LongRetry=%d\n", data );
    }
    else
        TI_SetLongRetry(g_id_adapter, parm[0].value);
}

void cmd_start_driver(ConParm_t parm[], U16 nParms)
{
    TI_Start( g_id_adapter );
}

void cmd_stop_driver(ConParm_t parm[], U16 nParms)
{
    UNUSED(nParms);
    UNUSED(parm);
    TI_Stop(g_id_adapter);
}
static TI_HANDLE eventRegistered[IPC_EVENT_MAX];

static named_value_t event_type[] = {
    { IPC_EVENT_ASSOCIATED,             "Associated" },
    { IPC_EVENT_DISASSOCIATED,          "Disassociated"  },
    { IPC_EVENT_LINK_SPEED,             "LinkSpeed" },
    { IPC_EVENT_AUTH_SUCC,              "Authentication Success" },
    { IPC_EVENT_SCAN_COMPLETE,          "ScanComplete" },
    { IPC_EVENT_TIMEOUT,                "Timeout" },
    { IPC_EVENT_CCKM_START,             "CCKM_Start" },
    { IPC_EVENT_MEDIA_SPECIFIC,         "Media_Specific" },
    { IPC_EVENT_EAPOL,                  "EAPOL" },
    { IPC_EVENT_BOUND,                  "Bound" },
    { IPC_EVENT_UNBOUND,                "Unbound" },
    { IPC_EVENT_PREAUTH_EAPOL,          "PreAuth EAPOL"},
/*  { IPC_EVENT_PER,                    "PER" },*/
    { IPC_EVENT_LOW_SNR,               "Low SNR" },
    { IPC_EVENT_LOW_RSSI,               "Low RSSI" },
    { IPC_EVENT_TSPEC_STATUS,           "IPC_EVENT_TSPEC_STATUS" },
    { IPC_EVENT_TSPEC_RATE_STATUS,      "IPC_EVENT_TSPEC_RATE_STATUS" },
    { IPC_EVENT_MEDIUM_TIME_CROSS,      "IPC_EVENT_MEDIUM_TIME_CROSS" },
    { IPC_EVENT_ROAMING_COMPLETE,       "ROAMING_COMPLETE"},
    { IPC_EVENT_EAP_AUTH_FAILURE,       "EAP-FAST/LEAP Auth Failed"},
    { IPC_EVENT_WPA2_PREAUTHENTICATION, "IPC_EVENT_WPA2_PREAUTHENTICATION" },
    { IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, "IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED" },
    { IPC_EVENT_BT_COEX_MODE, 	"IPC_EVENT_BT_COEX_MODE" },

};


void cmd_events_register(ConParm_t parm[], U16 nParms)
{
    tiUINT32 event;
    IPC_EVENT_PARAMS pEvent;

   if( nParms )
   {
        event = (tiUINT32)parm[0].value;

        if (events_mask & (1 << event))
        {
#ifndef _WINDOWS
            console_printf_terminal("cmd_events_register, event is already enabled! (%d)\n", events_mask);
#endif
        }
        else
   {
        pEvent.uEventType       = (tiUINT32)parm[0].value;
        pEvent.uDeliveryType      = DELIVERY_PUSH;
        pEvent.pfEventCallback = cli_receive_ev;
#ifdef _WINDOWS
#endif
        if( !TI_RegisterEvent(g_id_adapter, &pEvent) )
            {
            eventRegistered[pEvent.uEventType] = pEvent.uEventID;

                events_mask |= (1 << event);
#ifdef _WINDOWS
#endif
            }
        }
        }
    else
        {
#ifdef _WINDOWS
#else
		print_available_values(event_type);
#endif
    }

        }
void cmd_events_unregister(ConParm_t parm[], U16 nParms)
{
    tiUINT32 event;
    IPC_EVENT_PARAMS pEvent;

   if( nParms )
   {
        event = (tiUINT32)parm[0].value;
#ifdef _WINDOWS
#else
        pEvent.uEventType = event;
        pEvent.uEventID = eventRegistered[pEvent.uEventType];
        TI_UnRegisterEvent(g_id_adapter, &pEvent);

        events_mask &= ~(1 << event);
#endif
    }
    else
    {
#ifdef _WINDOWS
#else
        print_available_values(event_type);
#endif
    }
}

void cmd_get_selected_bssid_info(ConParm_t parm[], U16 nParms)
{
   OS_802_11_BSSID_EX myInfo;
   TI_GetSelectedBSSIDInfo(g_id_adapter, &myInfo);

   console_printf_terminal("Selected BSSID Info:\n");
   console_printf_terminal("--------------------\n");
   console_printf_terminal("SSID: %s\n", get_ssid_string(&myInfo.Ssid));
   console_printf_terminal("BSSID: %02x.%02x.%02x.%02x.%02x.%02x\n",
          myInfo.MacAddress[0], myInfo.MacAddress[1], myInfo.MacAddress[2], myInfo.MacAddress[3], myInfo.MacAddress[4], myInfo.MacAddress[5] );
}

int parseBssidIe(OS_802_11_BSSID_EX * bssid)
{
    OS_802_11_VARIABLE_IEs *pData;
    dot11_WME_PARAM_t *  qosParams;

    int length;
    int retval = 0;
    /* console_printf_terminal("parseBssidIe,IElength=%d \n",bssid->IELength);*/
    for (
            length =sizeof(OS_802_11_FIXED_IEs) , pData = (OS_802_11_VARIABLE_IEs*) ((char*)bssid->IEs + sizeof(OS_802_11_FIXED_IEs));
            length < (int)(bssid->IELength-3);
            length += (pData->Length +2),pData =  (OS_802_11_VARIABLE_IEs*)((char*)bssid->IEs  + length)
        )
    {
        /* console_printf_terminal("ElementID=%d pData=%x length=%d length1=%d\n",pData->ElementID,pData,pData->Length,length);*/
        if (pData->ElementID == DOT11_WME_ELE_ID)
        {
            qosParams = (dot11_WME_PARAM_t *)pData;
            /* console_printf_terminal("OUIType=%x OUI =%x %x %x \n",qosParams->OUIType,qosParams->OUI[0],qosParams->OUI[1],qosParams->OUI[2]);*/
            if (qosParams->OUIType == dot11_WME_OUI_TYPE)
            {
                retval |= dot11_WME_OUI_TYPE;
            }


        }
    }


    return retval;
}

void cmd_bssid_list(ConParm_t parm[], U16 nParms)
{

    OS_802_11_BSSID_EX BssIdInfo;
    TI_GetSelectedBSSIDInfo(g_id_adapter, &BssIdInfo);
    get_bssid_list(parm, nParms, FALSE , &BssIdInfo );
}

void cmd_Full_bssid_list(ConParm_t parm[], U16 nParms)
{
    OS_802_11_BSSID_EX BssIdInfo;
    TI_GetSelectedBSSIDInfo(g_id_adapter, &BssIdInfo);
    get_bssid_list(parm, nParms, TRUE , &BssIdInfo);
}

/*When beacon filter is activated, the current RSSI of the connection with the AP will be displayed despite no beacons are
 *passed up to the driver*/
static void get_bssid_list(ConParm_t parm[], U16 nParms, BOOL fullBssidList , OS_802_11_BSSID_EX *pBssid)
{
    OS_802_11_BSSID_LIST_EX *list;/* = (OS_802_11_BSSID_LIST_EX *) data; */
    OS_802_11_BSSID_EX *bssid;
    tiUINT32 number_items, index;
    char buffer[8] ;
    int Qos = 0;
	BOOL isConnectedAp = FALSE ;   //TRS:MEB move this line earlier to avoid compile error
    buffer[0] ='\0';

    UNUSED(nParms);
    UNUSED(parm);

    if (fullBssidList)
    {
        if( TI_GetFullBSSIDList(g_id_adapter, &list) || !list )
            return ;
    }
    else
    {
    if( TI_GetBSSIDList(g_id_adapter, &list) || !list )
        return ;
    }


    bssid = &list->Bssid[0];
    number_items = list->NumberOfItems;

    console_printf_terminal("BssId List: Num=%u\n", number_items );

    if( number_items )
    {
        console_printf_terminal("%17s %7s %4s %5s %7s  %10s %s\n", "MAC", "Privacy", "Rssi", "Infra", "Channel","Qos   ", "SSID");
        while (number_items)
        {
            Qos = parseBssidIe(bssid);

/*          console_printf_terminal("Qos=%d\n",Qos);*/
            if (Qos & dot11_WME_OUI_TYPE)
            {
                strcpy(buffer, "WME ");
            }

            if (Qos == 0)
            {
                strcpy(buffer, "NONE ");
            }

            if (( 0 == memcmp(pBssid->MacAddress ,bssid->MacAddress,sizeof(OS_802_11_MAC_ADDRESS)) ) &&
				(pBssid->NetworkTypeInUse == bssid->NetworkTypeInUse))
            {
                /*bssid->Rssi = staRssi ;*/
                isConnectedAp = TRUE ;
            }
            else
            {
                isConnectedAp = FALSE ;
            }

            console_printf_terminal("%s %s %7u %4d %5d %7d %10s %s\n",
                    ( TRUE == isConnectedAp)?"*":" " ,
                    print_mac_2_str(bssid->MacAddress),
                    bssid->Privacy, bssid->Rssi,
                    bssid->InfrastructureMode, Freq2Chan(bssid->Configuration.Union.channel),
                    buffer,
                    get_ssid_string(&bssid->Ssid) );

            if (fullBssidList)
            {
                console_printf_terminal("   TSF 0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x\n",
                      bssid->IEs[0], bssid->IEs[1], bssid->IEs[2], bssid->IEs[3],
                      bssid->IEs[4], bssid->IEs[5], bssid->IEs[6], bssid->IEs[7]);
                console_printf_terminal("   BeaconInterval 0x%02x%02x\n",  bssid->IEs[9], bssid->IEs[8]);
                console_printf_terminal("   Capabilities   0x%02x%02x\n",  bssid->IEs[10], bssid->IEs[11]);
                console_printf_terminal("   Variable IEs:\n");
                for (index=12; index<bssid->IELength; index++)
                {
                    if ((index-12)%8 == 0)
                    {
                        console_printf_terminal("\n   ");
                    }
                    console_printf_terminal("0x%02x ",bssid->IEs[index]);

                }
                console_printf_terminal("\n");
            }
            bssid = (OS_802_11_BSSID_EX *) (((char *) bssid) + bssid->Length);
            number_items--;
        }
        console_printf_terminal("Infra.mode:");
        print_available_values(BSS_type);
    }

    free(list);
}

#ifdef _WINDOWS
#else
PACKED_STRUCT( OS_802_11_BSSID_EX_TEMP,
	tiUINT32                  Length;
	OS_802_11_MAC_ADDRESS     MacAddress;
    PACKED_UNION(Union,
        tiUINT8  Reserved[2];
        tiUINT16 Capabilities;
    );
	OS_802_11_SSID            Ssid;
	tiUINT32                  Privacy;
	OS_802_11_RSSI            Rssi;
	OS_802_11_NETWORK_TYPE    NetworkTypeInUse;
	OS_802_11_CONFIGURATION   Configuration;
	OS_802_11_NETWORK_MODE    InfrastructureMode;
	OS_802_11_RATES_EX        SupportedRates;
	tiUINT32                  IELength;
	tiUINT8                   IEs[MAX_BEACON_BODY_LENGTH+sizeof(OS_802_11_FIXED_IEs)];
);
#endif


void cmd_FullPrimaryBbssid(ConParm_t parm[], U16 nParms)
{
    OS_802_11_BSSID_EX_TEMP bssid;
    OS_802_11_BSSID_EX_TEMP *pBssid = &bssid;
    UINT32  index;
    char buffer[8] ;
    int Qos = 0;
    buffer[0] ='\0';

    UNUSED(nParms);
    UNUSED(parm);

    memset(pBssid, 0, sizeof(OS_802_11_BSSID_EX));
    pBssid->Length = sizeof(OS_802_11_BSSID_EX) + sizeof(OS_802_11_FIXED_IEs) + MAX_BEACON_BODY_LENGTH;
    if( TI_GetPrimaryBSSIDInfo(g_id_adapter, (OS_802_11_BSSID_EX*)pBssid))
            return ;

    console_printf_terminal("Primary BssId: Length = %d, IELength=%d \n" , pBssid->Length, pBssid->IELength);

    if (pBssid->Length > sizeof(OS_802_11_BSSID_EX) + sizeof(OS_802_11_FIXED_IEs) + MAX_BEACON_BODY_LENGTH)
    {
        console_printf_terminal("Error - Length = %d is too long!!\n", pBssid->Length);
        return;
    }
    if (pBssid->Length < pBssid->IELength)
    {
        console_printf_terminal("Error - IELength = %d is too long!!\n", pBssid->IELength);
        pBssid->IELength = 50;
        print_mac_2_str(pBssid->MacAddress),

        console_printf_terminal("SSID len=%d\n", pBssid->Ssid.SsidLength);

        return;
    }
    console_printf_terminal("%17s %7s %4s %5s %7s  %10s %s\n", "MAC", "Privacy", "Rssi", "Infra", "Channel","Qos   ", "SSID");
    Qos = parseBssidIe((OS_802_11_BSSID_EX*)pBssid);

    if (Qos & dot11_WME_OUI_TYPE)
    {
        strcpy(buffer, "WME ");
    }

    if (Qos == 0)
    {
        strcpy(buffer, "NONE ");
    }

    console_printf_terminal("%s %7u %4d %5d %7d %10s %s\n",
            print_mac_2_str(pBssid->MacAddress),
            pBssid->Privacy, pBssid->Rssi,
            pBssid->InfrastructureMode, Freq2Chan(pBssid->Configuration.Union.channel),
            buffer,
            get_ssid_string(&pBssid->Ssid) );

    {
        console_printf_terminal("   TSF 0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x\n",
              pBssid->IEs[0], pBssid->IEs[1], pBssid->IEs[2], pBssid->IEs[3],
              pBssid->IEs[4], pBssid->IEs[5], pBssid->IEs[6], pBssid->IEs[7]);
        console_printf_terminal("   BeaconInterval 0x%02x%02x\n",  pBssid->IEs[9], pBssid->IEs[8]);
        console_printf_terminal("   Capabilities   0x%02x%02x\n",  pBssid->IEs[10], pBssid->IEs[11]);
        console_printf_terminal("   Variable IEs:\n");
        for (index=12; index<pBssid->IELength; index++)
        {
            if ((index-12)%8 == 0)
            {
                console_printf_terminal("\n   ");
            }
            console_printf_terminal("0x%02x ",pBssid->IEs[index]);

        }
        console_printf_terminal("\n");
    }
    console_printf_terminal("\nInfra.mode:");
    print_available_values(BSS_type);
}

void cmd_file_load(ConParm_t parm[], U16 nParms)
{
    consoleRunScript((char *) parm[0].value);
}

#ifdef TI_DBG

struct report_bit_desc_t
{
    int index;
    char *desc;
};

struct report_bit_desc_t report[] =
{

    /* Set 0 */
    { CONFIG_MGR_MODULE_LOG,        "CONFIG_MGR" },
    { SME_SM_MODULE_LOG,            "SME_SM" },
    { SITE_MGR_MODULE_LOG,          "SITE_MGR" },
    { CONN_MODULE_LOG,              "CONN" },
    { MLME_SM_MODULE_LOG,           "MLMEE" },
    { AUTH_MODULE_LOG,              "AUTH" },
    { ASSOC_MODULE_LOG,             "ASSOC" },
    { RX_DATA_MODULE_LOG,           "RX_DATA" },
    { TX_DATA_MODULE_LOG,           "TX_DATA" },
    { CTRL_DATA_MODULE_LOG,         "CTRL_DATA" },
    { RSN_MODULE_LOG,               "RSN" },
    { HAL_RX_MODULE_LOG,            "HAL_RX" },
    { HAL_TX_MODULE_LOG,            "HAL_TX" },
    { HAL_CTRL_MODULE_LOG,          "HAL_CTRL" },
    { HAL_SECURITY_MODULE_LOG,      "HAL_SECUR" },
    { MEM_MGR_MODULE_LOG,           "MEM_MGR" },
    { REPORT_MODULE_LOG,            "REPORT" },
    { SITE_UPDATE_MODULE_LOG,       "SITE_UPDATE" },
    { REGULATORY_DOMAIN_MODULE_LOG, "REG_DOMAIN" },
    { MEASUREMENT_MNGR_MODULE_LOG,  "MEASUREMENT_MNGR" },
    { MEASUREMENT_SRV_MODULE_LOG,   "MEASUREMENT_SRV" },
    { SOFT_GEMINI_MODULE_LOG,       "SOFT_GEMINI" },
    { SC_MODULE_LOG,                "SC (Switch Channel)" },
    { EXC_MANAGER_MODULE_LOG,       "EXC_MANAGER" },
    { ROAMING_MANAGER_MODULE_LOG,   "ROAMING_MANAGER" },
    { QOS_MANAGER_MODULE_LOG,       "QOS_MANAGER" },
    { TRAFFIC_ADM_CTRL_MODULE_LOG,  "TRAFFIC_ADM_CTRL" },
    { POWER_MANAGER_MODULE_LOG,     "POWER_MANAGER" },
    { POWER_CONTROL_MODULE_LOG,     "POWER_CONTROL" },
    { POWER_SERVER_MODULE_LOG,      "POWER_SERVER" },
    { ELP_MODULE_LOG,               "ELP" },
    { SCR_MODULE_LOG,               "SCR" },
    { SCAN_SRV_MODULE_LOG,          "SCAN_SRV" },
    { SCAN_CNCN_MODULE_LOG,         "SCAN_CNCN" },
    { SCAN_MNGR_MODULE_LOG,         "SCAN_MNGR" },
    { GWSI_ADAPT_MODULE_LOG,        "GWSI_ADAPT" },
    { GWSI_ADAPT_CB_MODULE_LOG,     "GWSI_ADAPT_CB" },
    { CORE_ADAPT_MODULE_LOG,        "CORE_ADAPT" },
    { TX_HW_QUEUE_MODULE_LOG,       "TX HW QUEUE" },
    { TX_CTRL_BLK_MODULE_LOG,       "TX CTRL BLK" },
    { TX_RESULT_MODULE_LOG,         "TX RESULT" },
    { TNETW_IF_MODULE_LOG,          "TNETW IF" },
    { TNETW_ARBITER_MODULE_LOG,     "TNETW ARBITER" },
    { CURR_BSS_MODULE_LOG,          "CURR_BSS" },
    { FW_EVENT_MODULE_LOG,          "FW_EVENT" },
    { CMD_MBOX_MODULE_LOG,          "CMD_MBOX" },
	{ CMDQUEUE_MODULE_LOG,          "CMD_QUEUE" },
    { EVENT_MBOX_MODULE_LOG,        "EVENT_MBOX"},
    { TNETW_DRV_MODULE_LOG,         "TNETW DRV" },
	{ TNETW_XFER_MODULE_LOG,        "TX XFER" },
    { RECOVERY_MGR_MODULE_LOG,      "RECOVERY MGR" },
    { RECOVERY_CTRL_MODULE_LOG,     "RECOVERY CTRL" },
    { HW_INIT_MODULE_LOG,           "HW INIT" }

};


struct rep_severity_level_t {
    U8 level;
    char *desc;
};

static struct rep_severity_level_t report_severity_level[] = {
    { 0,                          "----"           },
    { WLAN_SEVERITY_INIT,         "INIT",          },
    { WLAN_SEVERITY_INFORMATION,  "INFORMATION",   },
    { WLAN_SEVERITY_WARNING,      "WARNING",       },
    { WLAN_SEVERITY_ERROR,        "ERROR",         },
    { WLAN_SEVERITY_FATAL_ERROR,  "FATAL_ERROR",   },
    { WLAN_SEVERITY_SM,           "SM",            },
    { WLAN_SEVERITY_CONSOLE,      "CONSOLE",       },
    { WLAN_SEVERITY_DEBUG_RX,     "DEBUG RX",      },
    { WLAN_SEVERITY_DEBUG_TX,     "DEBUG TX",      },
    { WLAN_SEVERITY_DEBUG_CONTROL,"DEBUG CONTROL", },
    { WLAN_SEVERITY_GWSI_RECORDING,"GWSI RECORDING"}
};

static void print_report_module_desc(void)
{
    int i;
    tiUINT8 module_table[WLAN_MAX_LOG_MODULES];

    if (!TI_GetReportModule(g_id_adapter, module_table))
    {
        console_printf_terminal("-------------------------------\n");
        console_printf_terminal("%.5s\tState\t %s\n", "Index", "Desc");

        for( i = 0; i < SIZE_ARR(report); i++)
        {
            /* Check if there is string content (the first character is not ZERO) */
            if( report[i].desc[0] )
            {
                console_printf_terminal("%3d\t%c\t%s\n", report[i].index, (module_table[i] == '1') ? '+' : ' ', report[i].desc );
            }
        }
    }
    else
    {
        console_printf_terminal("Error reading the report table form the driver\n");
    }
}

void cmd_report_add(ConParm_t parm[], U16 nParms)
{
    tiUINT8 module_table[WLAN_MAX_LOG_MODULES];

    if( nParms != 1)
    {
        print_report_module_desc();
        console_printf_terminal( "* Use '%d' (max index) to set all table.\n", WLAN_MAX_LOG_MODULES);
    }
    else if(!TI_GetReportModule(g_id_adapter, module_table))
    {
        if (parm[0].value == WLAN_MAX_LOG_MODULES)
        {
            memset(module_table, '1', sizeof(module_table));
        }
        else if(parm[0].value < WLAN_MAX_LOG_MODULES)
        {
            module_table[parm[0].value] = '1';
        }
        TI_SetReportModule(g_id_adapter, module_table);
    }
}

void cmd_report_clear(ConParm_t parm[], U16 nParms)
{
    tiUINT8 module_table[WLAN_MAX_LOG_MODULES + 1];

    if( nParms != 1)
    {
        print_report_module_desc();
        console_printf_terminal( "* Use '%d' (max index) to clear all table.\n", WLAN_MAX_LOG_MODULES);
    }
    else if(!TI_GetReportModule(g_id_adapter, module_table))
    {
        if (parm[0].value == WLAN_MAX_LOG_MODULES)
        {
            memset(module_table, '0', WLAN_MAX_LOG_MODULES);
        }
        else if (parm[0].value < WLAN_MAX_LOG_MODULES)
        {
            module_table[parm[0].value] = '0';
        }
        TI_SetReportModule(g_id_adapter, module_table);
    }
}

void cmd_report_set(ConParm_t parm[], U16 nParms)
{
    U8 *ModuleTable = (U8 *)parm[0].value;

    if( nParms != 1)
    {
        print_report_module_desc();
    }
    else
    {
#ifdef _WINDOWS
#endif /* _WINDOWS */

        TI_SetReportModule(g_id_adapter, ModuleTable);
    }
}

void cmd_hw_register(ConParm_t parm[], U16 nParms)
{
    tiUINT32 data;

#ifndef _WINDOWS
        usleep(10 * 1000);
#elif defined (_WINDOWS)
#endif

    if( nParms == 1 )
    {
        if( !TI_hwReadRegister(g_id_adapter, parm[0].value, &data ) )
        {
#ifdef _WINDOWS
#endif
        }
    }
    else
    {
        TI_hwWriteRegister(g_id_adapter, parm[0].value, parm[1].value );
    }
}

void cmd_debug_driver_print(ConParm_t parm[], U16 nParms)
    {
        tiUINT32 func_id = ( nParms > 0 ) ? parm[0].value : 0;
        tiUINT32 opt_param = ( nParms > 1 ) ? parm[1].value : 0;
        tiUINT32 buf[2] = { func_id, opt_param };

        console_printf_terminal("DRV_PRINT: FUNC:%u, PARAM:%u\n", func_id, opt_param);
        TI_DisplayStats(g_id_adapter, (tiUINT8 *) buf, sizeof(buf) );
        /* tiwlan_driver_debug_print( g_drv_name, func_id, opt_param ); */
}

void cmd_debug_buffer_put(ConParm_t parm[], U16 nParms)
    {
        tiUINT32 func_id = ( nParms > 0 ) ? parm[0].value : 0;
        tiUINT32 opt_param = ( nParms > 1 ) ? parm[1].value : 0;
        tiUINT8 buf[260];  /* no more then 256 + func id */

        if (opt_param == 0)
            return;
        *(tiUINT32*) buf = func_id;
        memcpy (buf + sizeof(func_id),(char *)opt_param,strlen((char *)opt_param));

        console_printf_terminal("cmd_debug_buffer_put: FUNC:%u, PARAM:%u\n", func_id, opt_param);
        TI_DisplayStats(g_id_adapter, (tiUINT8 *) buf, strlen((char *)opt_param) +  sizeof(func_id));
        /* tiwlan_driver_debug_print( g_drv_name, func_id, opt_param ); */
}

static void print_severity_table(tiUINT8 *pTable)
{
    int i;

    console_printf_terminal("Severity:\n");
    console_printf_terminal("-------------------------------\n");
    console_printf_terminal("%14s\tState\t%s\n", "Severity level", "Desc");

    for( i=1; i<SIZE_ARR(report_severity_level); i++ )
    {
        console_printf_terminal("%d\t%c\t%s\n", report_severity_level[i].level, (pTable[i] == '1') ? '+' : ' ',report_severity_level[i].desc );
    }

    console_printf_terminal( "* Use '0' to clear all table.\n");
    console_printf_terminal( "* Use '%d' (max index) to set all table.\n", SIZE_ARR(report_severity_level));
}

void cmd_report_severity_table(ConParm_t parm[], U16 nParms)
{
    U8 *pSeverityTable = (U8 *)parm[0].value;
    tiUINT8 SeverityTable[WLAN_MAX_SEVERITIES];
#ifdef _WINDOWS
#endif /* _WINDOWS */
    if( nParms != 1)
    {
        if (!TI_GetReportSeverity( g_id_adapter, &SeverityTable[0]))
        {
            print_severity_table(SeverityTable);
        }
    }
    else
    {
        TI_SetReportSeverity(g_id_adapter, pSeverityTable);
    }
}

void cmd_report_severity_level(ConParm_t parm[], U16 nParms)
{
    tiUINT8 SeverityTable[WLAN_MAX_SEVERITIES];

    /* Get the current report severity */
    if (!TI_GetReportSeverity( g_id_adapter, &SeverityTable[0]))
    {
        if(nParms == 0)
        {
            /* Parameters error - print the current table values */
            print_severity_table(SeverityTable);
        }
        else
        {
            if (parm[0].value == 0)
            {
                /* Disable all severity levels */

                memset(SeverityTable, (int)('0'), sizeof(SeverityTable));

                TI_SetReportSeverity(g_id_adapter, SeverityTable);
            }
            else if (parm[0].value == SIZE_ARR(report_severity_level))
            {
                /* Enable all severity levels */

                memset(SeverityTable, (int)('1'), sizeof(SeverityTable));

                TI_SetReportSeverity(g_id_adapter, SeverityTable);
            }
            else if (parm[0].value < SIZE_ARR(report_severity_level))
            {
                console_printf_terminal("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';
                }

                TI_SetReportSeverity(g_id_adapter, SeverityTable);
            }
            else
            {
                console_printf_terminal("invalid level value: %#lx\n", parm[0].value );
            }
        }
    }
    else
    {
        console_printf_terminal("Error retriving the severity table from the driver\n");
    }
}


#ifdef DRIVER_PROFILING

void cmd_profile_report(ConParm_t parm[], U16 nParms)
{
    TI_ProfileReport( g_id_adapter );
}


void cmd_profile_cpu_estimator_command(ConParm_t parm[], U16 nParms)
{
    /* reset or stop command */
    if (nParms == 1) {
        //printf("cpu_profile_cpu_estimator: param[0] = %d\n", (tiUINT8)parm[0].value);
        TI_CpuEstimatorCommand(g_id_adapter, (tiUINT8)parm[0].value, 0);
    }
    else /* start command */
    {
        //printf("cpu_profile_cpu_estimator: param[0] = %d, param[1] = %d\n",(tiUINT8)parm[0].value,(tiUINT32)parm[1].value);
        TI_CpuEstimatorCommand(g_id_adapter, (tiUINT8)parm[0].value,(tiUINT32)parm[1].value);
    }
}

#endif

void cmd_report_os_dbg_state(ConParm_t parm[], U16 nParms)
{
    UINT32 dwOsDbgState;

    if(nParms == 0) {
        if (TI_GetOsDbgState( g_id_adapter, &dwOsDbgState) == TI_RESULT_OK) {
            console_printf_terminal("OsDbgState %d (0x%08X)\n", dwOsDbgState, dwOsDbgState);
        }
        else {
            console_printf_terminal("Error retriving the OsDbgState from the driver\n");
        }
    }
    else {
        TI_SetOsDbgState(g_id_adapter, parm[0].value);
    }
}

#endif /* define TI_DBG */

void cmd_privacy_auth(ConParm_t parm[], U16 nParms)
{
    if( nParms )
    {
        TI_SetAuthenticationMode( g_id_adapter, (tiUINT32)parm[0].value );
        /*console_printf_terminal("CLI-AuthenticationMode: - %x",(tiUINT32)parm[0].value);*/
    }
    else
    {
        static named_value_t auth_mode_type[] = {
            { os802_11AuthModeOpen,             "Open"      },
            { os802_11AuthModeShared,           "Shared"    },
            { os802_11AuthModeAutoSwitch,       "AutoSwitch"},
            { os802_11AuthModeWPA,              "WPA"       },
            { os802_11AuthModeWPAPSK,           "WPAPSK"    },
            { os802_11AuthModeWPANone,          "WPANone"   },
            { os802_11AuthModeWPA2,             "WPA2"      },
            { os802_11AuthModeWPA2PSK,          "WPA2PSK"   },

            /*{ os802_11AuthModeMax,              "Max"       }*/
        };
        OS_802_11_AUTHENTICATION_MODE data;

        if( !TI_GetAuthenticationMode( g_id_adapter, &data ) )
        {
            print_available_values(auth_mode_type);
            console_printf_terminal("AuthenticationMode=%d\n", data );
        }
    }
}

void cmd_privacy_eap(ConParm_t parm[], U16 nParms)
{
    if( nParms )
    {
        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
    {
        static named_value_t eap_type[] = {
            { OS_EAP_TYPE_GENERIC_TOKEN_CARD,   "TOKEN" },
            { OS_EAP_TYPE_TLS,                  "TLS"   },
            INCLUDE_EXC_TYPE_NAMES
            { OS_EAP_TYPE_TTLS,                 "TTLS"  },
            { OS_EAP_TYPE_PEAP,                 "PEAP"  },
            {OS_EAP_TYPE_MS_CHAP_V2,            "CHAP"  }
        };
/*temp_closed
        OS_802_11_EAP_TYPES data;

        if( !TI_GetEAPType( g_id_adapter, &data ) )
        {
            print_available_values(eap_type);
            console_printf_terminal("EAP Type = %d\n", data );
        }
*/
    print_available_values(eap_type);
    }

}


void cmd_privacy_encrypt(ConParm_t parm[], U16 nParms)
{
   OS_802_11_ENCRYPTION_TYPES data;
   if( nParms )
    {
        TI_SetEncryptionType( g_id_adapter, (OS_802_11_ENCRYPTION_TYPES) parm[0].value );
    }
    else
    {
        print_available_values(encrypt_type);
        console_printf_terminal("Encryption=%d\n", !TI_GetEncryptionType( g_id_adapter, &data ) ? data : -1 );
    }

}
void cmd_privacy_credent(ConParm_t parm[], U16 nParms)
{

    if( nParms == 2 )
    {
        TI_SetCredentials(g_id_adapter,(tiCHAR *) parm[0].value, (tiCHAR *) parm[1].value);
    }
    else if( nParms == 1 )
        TI_SetCredentials(g_id_adapter,(tiCHAR *) parm[0].value, NULL);
    else
        return;

}

void cmd_privacy_PSKPassphrase(ConParm_t parm[], U16 nParms)
{
    char buf[PSK_BUFF_LEN], *pPassphrase;
    unsigned int len, is_hex_key = 0;


	if( nParms == 0 )
        return;

	len = strlen((char*)(parm[0].value));

	pPassphrase = (char*)(parm[0].value);

	memset(buf,0,PSK_BUFF_LEN);

    if( nParms >= 2 )
    {
#ifdef _WINDOWS
#else
        if( !stricmp((char *) parm[1].value, "hex") )
            is_hex_key = 1;
        else if(!stricmp((char *) parm[1].value, "text"))
            is_hex_key = 0;
#endif
    }

    if( is_hex_key )
    {
		if( len != PSK_HEXA_LENGTH )
        {
            console_printf_terminal("The hexa PSKPassphrase must be at length of %d hexa digits \n",PSK_HEXA_LENGTH);
            return ;
        }
    }
	else
	{
		if (len > MAX_PSK_STRING_LENGTH || len < MIN_PSK_STRING_LENGTH)
		{
            console_printf_terminal("The PSKPassphrase must be between %d to  %d chars \n", MIN_PSK_STRING_LENGTH, MAX_PSK_STRING_LENGTH);
            return ;
        }
	}

	memcpy(buf, (char*)(parm[0].value), len);

	/*TI_SetPSKPassPhrase*/
	TI_SetPSK(g_id_adapter, (tiCHAR *)buf);
}

void cmd_privacy_certificate(ConParm_t parm[], U16 nParms)
{
#ifdef _WINDOWS // TRS:HLC
#else
    console_printf_terminal("Set sertificate file : %s\n", (char*)parm[0].value);
    if(nParms == 1 )
        TI_SetCertificateParameters(g_id_adapter, (void*)parm[0].value, 0);
    else if(nParms == 2 )
        TI_SetCertificateParameters(g_id_adapter, (void*)parm[0].value,
                                                   (unsigned int)parm[1].value);
    else return;
#endif
//TRS end
}

void cmd_privacy_wpa_options(ConParm_t parm[], U16 nParms)
{
    if( nParms )
    {
        TI_SetWpaOptions(g_id_adapter, parm[0].value );
    }
    else
    {
        tiUINT32 data;
        static named_value_t wpa_options[] = {
            { OS_802_11_OPTION_ENABLE_PROMOTE_MODE,   "PROMOTE_MODE" },
            { OS_802_11_OPTION_ENABLE_PROMOTE_CIPHER, "PROMOTE_CIPHER"   },
            { OS_802_11_OPTION_ENABLE_ALL,            "All" }
        };

        print_available_values(wpa_options);
        if( !TI_GetWpaOptions(g_id_adapter, &data ) )
            console_printf_terminal("WPA option=%d\n", data );
    }
}

void cmd_privacy_getdefaultkey(ConParm_t parm[], U16 nParms)
{
    tiUINT32 DefaultKeyId;
    if (OK == TI_GetDefaultWepKey(g_id_adapter, &DefaultKeyId))
        console_printf_terminal("WEP default key ID = %d\n", DefaultKeyId );

}
unsigned int char_2_hexa( char c )
{
    if( c >= '0' && c <= '9' )
        return c - '0';
    else if( tolower(c) >= 'a' && tolower(c) <= 'f' )
        return tolower(c) - 'a' + 0x0a;
    console_printf_terminal("invalid symbol '%c'\n", c );
    return (unsigned int) -1;
}

void cmd_privacy_addkey(ConParm_t parm[], U16 nParms)
{
    OS_802_11_WEP data;
    char *buf;
    unsigned int i, len, is_hex_key = 1;
    U32 val, val_l;
    unsigned int key_id = 0;
    unsigned int def_flag = 0;

    buf = (char *) parm[0].value;

    key_id = (unsigned int)parm[1].value;

    if( parm[2].value )
        def_flag = 0x80000000;

    if( nParms >= 4 )
    {
#ifdef _WINDOWS
#else
        if( !stricmp((char *) parm[3].value, "hex") )
            is_hex_key = 1;
        else if(!stricmp((char *) parm[3].value, "text"))
            is_hex_key = 0;
#endif
    }

    memset(data.KeyMaterial,0,sizeof(data.KeyMaterial));

    len = strlen(buf);

    if( is_hex_key )
    {
        if( len % 2 )
        {
            console_printf_terminal("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 {
                console_printf_terminal("**Error key length\n" );
                return;
        }

        for( i=0; *buf && i < data.KeyLength; i++ )
        {
                val = char_2_hexa(*buf);
                if( val == (U32) -1 )
                    return;

                val_l = char_2_hexa(*(++buf));
                if( val_l == (U32) -1 )
                    return;

                data.KeyMaterial[i] = (tiUINT8)((val << 4) | val_l);
                buf++;
        }
    }
    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 {
                console_printf_terminal("**Error key length\n" );
                return;
        }
        memcpy(data.KeyMaterial, buf, len );
    }

    data.KeyIndex = def_flag | key_id;
    data.Length = sizeof(OS_802_11_WEP);

#ifdef DEBUG_MESSAGES
    console_printf_terminal("cmd_privacy_addkey len = %d, type: %s\nkey:", data.KeyLength, is_hex_key ? "hex" : "text");
    for(i=0; i<SIZE_ARR(data.KeyMaterial); i++ )
        console_printf_terminal("%02x", (U32) data.KeyMaterial[i]);
    console_printf_terminal("\n");
#endif /*DEBUG_MESSAGES */
    TI_AddWEPKey(g_id_adapter, &data);
}


void cmd_privacy_removekey(ConParm_t parm[], U16 nParms)
{
    TI_RemoveWEPKey(g_id_adapter, (U32) parm[0].value );
}

void cmd_privacy_key_type(ConParm_t parm[], U16 nParms)
{

   if( nParms )
        {
        TI_SetKeyType( g_id_adapter, (OS_802_11_KEY_TYPES)parm[0].value );
        console_printf_terminal("CLI-: KeyType - %x\n",(tiUINT32)parm[0].value);
        }
    else
    {
        static named_value_t key_type[] = {
            { OS_KEY_TYPE_STATIC,             "STATIC" },
            { OS_KEY_TYPE_DYNAMIC,            "DYNAMIC"}
        };

        print_available_values(key_type);
    }

}
void cmd_privacy_mixed_mode(ConParm_t parm[], U16 nParms)
{
    tiBOOL data;

    if( nParms == 0 )
    {
       console_printf_terminal("Mixed Mode: 0 - FALSE, 1 - TRUE\n");
       data = FALSE;
       if( !TI_GetMixedMode(g_id_adapter, &data ) );
            console_printf_terminal("Mixed Mode =%s\n", data ? "True" : "False" );

    }
    else    /* param <read-only!!> */
        TI_SetMixedMode(g_id_adapter, (BOOL) parm[0].value);
}


/************** Roaming Manager functions  ******************/
void cmd_Roaming_enable(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_ENABLED;
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Roaming is enabled \n");
}


void cmd_Roaming_disable(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_DISABLED;
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Roaming is disabled \n");
}
void cmd_Roaming_lowPassFilter(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt = (UINT16) parm[0].value;
    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Time in sec to wait before low quality Roaming Triggers, \n lowPassFilterRoamingAttempt = %d sec\n",
           roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt);
}

void cmd_Roaming_qualityIndicator(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold = (S8) parm[0].value;
    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Quality indicator (RSSI) to be used when comparing AP List matching quality, \n apQualityThreshold = %d \n",
           (roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold));
}


void cmd_Roaming_dataRetryThreshold(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold = (UINT8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("dataRetryThreshold = %d \n",
           roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold);

}
void cmd_Roaming_numExpectedTbttForBSSLoss(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss =  (UINT8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Number of expected TBTTs for BSS Loss event, \n numExpectedTbttForBSSLoss = %d \n",
           roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss);

}
void cmd_Roaming_txRateThreshold(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold =  (UINT8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("txRateThreshold = %d \n",
           roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold);

}
void cmd_Roaming_lowRssiThreshold(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold =  (S8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("lowRssiThreshold = %d \n",
           (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold));

}
void cmd_Roaming_lowSnrThreshold(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold =  (S8)parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("lowSnrThreshold = %d \n", roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold);
}
void cmd_Roaming_lowQualityForBackgroungScanCondition(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition = (S8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Indicator used to increase the background scan period when quality is low, \n lowQualityForBackgroungScanCondition = %d \n",
           (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition));

}
void cmd_Roaming_normalQualityForBackgroungScanCondition(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition = (S8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Indicator used to reduce the background scan period when quality is normal, \n normalQualityForBackgroungScanCondition = %d \n",
           (roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition));

}

void cmd_Roaming_rssiFilterWeight(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.rssiFilterWeight =  (UINT8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Rssi Filter Weight = %d \n",
           (roamingMngrConfigParams.roamingMngrThresholdsConfig.rssiFilterWeight));
}

void cmd_Roaming_snrFilterWeight(ConParm_t parm[], U16 nParms)
{
    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    if( nParms != 0 )
    {
        roamingMngrConfigParams.roamingMngrThresholdsConfig.snrFilterWeight =  (UINT8) parm[0].value;

    }
    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
    console_printf_terminal("Snr FIlter Weight = %d \n",
           (roamingMngrConfigParams.roamingMngrThresholdsConfig.snrFilterWeight));
}

void cmd_Roaming_getConfParams(ConParm_t parm[], U16 nParms)
{
   TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));

   console_printf_terminal("Roaming is: %s \n", roamingMngrConfigParams.roamingMngrConfig.enableDisable ? "Enabled" : "Disabled");
   console_printf_terminal("lowPassFilterRoamingAttempt = %d sec, apQualityThreshold = %d\n",
          roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt,
		  roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold);
   console_printf_terminal("Roaming Triggers' thresholds are: \n");
   console_printf_terminal("dataRetryThreshold = %d, lowQualityForBackgroungScanCondition = %d, \
lowRssiThreshold = %d, lowSnrThreshold = %d, normalQualityForBackgroungScanCondition = %d, \
numExpectedTbttForBSSLoss = %d, txRateThreshold = %d \n",
          roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold,
		  roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition,
		  roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold,
          roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold,
		  roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition,
          roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss,
          roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold);
   console_printf_terminal("RSSI / SNR filter weights are: \n");
   console_printf_terminal("RSSI filter weight = %d, SNR filter weight = %d\n ",
   		roamingMngrConfigParams.roamingMngrThresholdsConfig.rssiFilterWeight,
   		roamingMngrConfigParams.roamingMngrThresholdsConfig.snrFilterWeight);
}


void cmd_bt_coe_enable(ConParm_t parm[], U16 nParms)
{
    if( nParms == 0 )
    {
        console_printf_terminal("Please enter enable value:\n");
        console_printf_terminal("0 - Enable\n");
        console_printf_terminal("1 - Disable\n");
        console_printf_terminal("2 - Auto\n");
    }
    else
    {
        TI_SetBtCoeEnable(g_id_adapter, parm[0].value);
    }
}


void cmd_bt_coe_rate(ConParm_t parm[], U16 nParms)
{
    U8 Values[NUM_OF_RATES_IN_SG];
    U8 Index;
    if( nParms != NUM_OF_RATES_IN_SG )
    {
 		console_printf_terminal("0 - 1Mbps (not recommended)\n");
		console_printf_terminal("1 - 2Mbps (not recommended)\n");
		console_printf_terminal("2 - 5.5Mbps\n");
		console_printf_terminal("3 - 6Mbps\n");
		console_printf_terminal("4 - 9Mbps\n");
		console_printf_terminal("5 - 11Mbps\n");
		console_printf_terminal("6 - 12Mbps\n");
		console_printf_terminal("7 - 18Mbps\n");
		console_printf_terminal("8 - 22Mbps (not in use)\n");
		console_printf_terminal("9 - 24Mbps\n");
		console_printf_terminal("10 - 36Mbps\n");
		console_printf_terminal("11 - 48Mbps\n");
		console_printf_terminal("12 - 54Mbps\n");
    }
    else
    {
        for (Index = 0; Index < NUM_OF_RATES_IN_SG; Index++ )
        {
			Values[Index] = (U8)parm[Index].value;  //TRS:MEB use cast to fix compile warning
        }
        TI_SetBtCoeRate(g_id_adapter, Values);
    }
}


void cmd_bt_coe_config(ConParm_t parm[], U16 nParms)
{
    U32 Values[NUM_OF_CONFIG_PARAMS_IN_SG];
    U8 Index = 0;

    if( nParms != NUM_OF_CONFIG_PARAMS_IN_SG )
    {
        console_printf_terminal("Please enter valid config values:\n");

		console_printf_terminal("Param %d - wlanRxMinRateToRespectBtHp (0 - all,2,5,6,9,11,12,18,22,24,36,48,54)  \n",Index++);
        console_printf_terminal("Param %d - btHpMaxTime (100 - 15000)\n",Index++);
        console_printf_terminal("Param %d - wlanHpMaxTime (100 - 15000)\n",Index++);
        console_printf_terminal("Param %d - senseDisableTimer (100 - 15000)\n",Index++);
        console_printf_terminal("Param %d - protectiveRxTimeBeforeBtHp (10 - 2300)\n",Index++);
        console_printf_terminal("Param %d - protectiveTxTimeBeforeBtHp (10 - 2300)\n",Index++);
        console_printf_terminal("Param %d - protectiveRxTimeBeforeBtHpFastAp (10 - 20000)\n",Index++);
        console_printf_terminal("Param %d - protectiveTxTimeBeforeBtHpFastAp (10 - 20000)\n",Index++);
        console_printf_terminal("Param %d - protectiveWlanCycleTimeForFastAp (2000 - 65535)\n",Index++);
        console_printf_terminal("Param %d - btAntiStarvationPeriod (0 - 15000) \n",Index++);
        console_printf_terminal("Param %d - timeoutNextBtLpPacket (400 - 10000)\n",Index++);
		console_printf_terminal("Param %d - wakeUpTimeBeforeBeacon   (0 - 20000)  \n",Index++);
		console_printf_terminal("Param %d - hpdmMaxGuardTime   (0 - 50000)  \n",Index++);
		console_printf_terminal("Param %d - timeoutNextWlanPacket   (100 - 50000)  \n",Index++);
        console_printf_terminal("Param %d - sgAntennaType (0 - Single | 1 - Dual | 2 - Single+ )\n",Index++);
        console_printf_terminal("Param %d - signalingType (0 - Legacy | 1 - Palau | 2 - Other)\n",Index++);
        console_printf_terminal("Param %d - afhLeverageOn (0 - OFF | 1 - GPIO  | 2 - ON)\n",Index++);
        console_printf_terminal("Param %d - numberQuietCycle (0 - 10)\n",Index++);
        console_printf_terminal("Param %d - maxNumCts (0 - 10)\n",Index++);
        console_printf_terminal("Param %d - numberOfWlanPackets (1 - 10)\n",Index++);
        console_printf_terminal("Param %d - numberOfBtPackets (2 - 10)\n",Index++);
        console_printf_terminal("Param %d - numberOfMissedRxForAvalancheTrigger (1 - 255)\n",Index++);
        console_printf_terminal("Param %d - wlanElpHpSupport (0 - 1)\n",Index++);
        console_printf_terminal("Param %d - btAntiStarvationNumberOfCyclesWithinThePeriod (0 - 15)  \n",Index++);
        console_printf_terminal("Param %d - ackModeDuringBtLpInDualAnt (0 - 1)  \n",Index++);
        console_printf_terminal("Param %d - allowPaSdToggleDuringBtActivityEnable (0 - 1)  \n",Index++);
		console_printf_terminal("Param %d - sgAutoModeNoCts   (0 - 1)  \n",Index++);
		console_printf_terminal("Param %d - numOfBtHpRespectedReq   (0 - 20)  \n",Index++);
   }
   else
    {
        for (Index = 0; Index < NUM_OF_CONFIG_PARAMS_IN_SG; Index++ )
        {
            Values[Index] = parm[Index].value;
        }

		if ( ( (is_value_rate(Values[0])) && (Values[0] != 1) ) || (Values[0] == 0) )
		{
			TI_SetBtCoeConfig(g_id_adapter, (tiUINT32 *)Values);
		}
		else
		{
			console_printf_terminal("Error: Param 26 - wlanRxMinRateToRespectBtHp (0 - all,2,5,6,9,11,12,18,22,24,36,48,54)  \n");
		}
    }
}


void cmd_bt_coe_get_status(ConParm_t parm[], U16 nParms)
{
    U32 Values[NUM_OF_STATUS_PARAMS_IN_SG];
    /* The print is done inside the module */
    console_printf_terminal("Done by driver - ");
    if( TI_SetBtCoeGetStatus(g_id_adapter,(tiUINT32 *) Values) == OK ) {
        console_printf_terminal("Ok\n");
/*      console_printf_terminal("BT Coxistence status: \n\n");
        console_printf_terminal("Enable: %d\n", Values[0]);
        console_printf_terminal("Rate: %d\n", Values[1]);
        console_printf_terminal("BtSignaling: %d\n", Values[2]);
        console_printf_terminal("BtHPMaxTime: %d\n", Values[3]);
        console_printf_terminal("WlanHPMaxTime: %d\n", Values[4]);
        console_printf_terminal("WlanEOSMaxPacket: %d\n", Values[5]);
        console_printf_terminal("WlanEOSMaxPacketTimeOut: %d\n", Values[6]);
        console_printf_terminal("BtPTAMaxPacket: %d\n", Values[7]);
        console_printf_terminal("BtPTAMaxPacketTimeOut: %d\n", Values[8]);
        console_printf_terminal("WlanSlowAPSocial: %d\n", Values[9]);
        console_printf_terminal("WlanSlowAPMaxCTS: %d\n", Values[10]);
        console_printf_terminal("WlanSlowAPMaxTimeToCTS: %d\n", Values[11]);
        console_printf_terminal("T8_temporary: %d\n", Values[12]);
        console_printf_terminal("BTtoWLANSwitchTime: %d\n", Values[13]); */
    }
    else
    {
        console_printf_terminal("Fail\n");
/*      console_printf_terminal("Error reading status!\n"); */
    }
}


void cmd_PLT_RxPerStart(ConParm_t parm[], U16 nParms)
{
	UINT32 Status = TI_PLT_RxPerStart(g_id_adapter);
	if (Status == OK)
		console_printf_terminal("Plt RX counters started\n");
	else
		console_printf_terminal("Plt RX counters start failed\n");
}

void cmd_PLT_RxPerStop(ConParm_t parm[], U16 nParms)
{
	UINT32 Status = TI_PLT_RxPerStop(g_id_adapter);
	if (Status == OK)
		console_printf_terminal("Plt RX counters stoped\n");
	else
		console_printf_terminal("Plt RX counters stop failed\n");
}

void cmd_PLT_RxPerClear(ConParm_t parm[], U16 nParms)
{
	UINT32 Status = TI_PLT_RxPerClear(g_id_adapter);
	if (Status == OK)
		console_printf_terminal("Plt RX counters cleard\n");
	else
		console_printf_terminal("Plt RX counters clear failed\n");
}

void cmd_PLT_RxPerGet(ConParm_t parm[], U16 nParms)
{
	PltRxPer_t PltRxPer;
	UINT32 Status = TI_PLT_RxPerGetResults(g_id_adapter, &PltRxPer);

	if (Status == OK)
	{
		console_printf_terminal("FCSErrorCount = %d\n", PltRxPer.FCSErrorCount);
		console_printf_terminal("PLCPErrorCount  = %d\n", PltRxPer.PLCPErrorCount);
        console_printf_terminal("SeqNumMissCount = %d\n", PltRxPer.SeqNumMissCount);
		console_printf_terminal("TotalFrameCount = %d\n", PltRxPer.TotalFrameCount);
	}
	else
		console_printf_terminal("Plt RX counters Get results failed\n");
}

void cmd_PLT_RegisterRead(ConParm_t parm[], U16 nParms)
{
    tiUINT32 RegAddress;
    tiUINT32 RegValue;
    tiUINT32 Status;
    char* pTmp;

    /* Converting hex string to tiUINT32*/
    pTmp = (char*)parm[0].value;
    sscanf(pTmp , "%x", &RegAddress);

    /*Call the API function */
    Status = TI_PLT_ReadRegister(g_id_adapter, RegAddress, &RegValue);
    if( Status == OK )
        console_printf_terminal("Reg. %#lx = %#x (%d)\n", RegAddress, RegValue, RegValue );
}

void cmd_PLT_RegisterWrite(ConParm_t parm[], U16 nParms)
{
    tiUINT32 RegAddress;
    tiUINT32 RegValue = 0;
    tiUINT32 Status;
    char* pTmp;

    /* Converting hex string to tiUINT32*/
    printf("cmd_PLT_RegisterWrite\n");
    pTmp = (char*)parm[0].value;
    sscanf(pTmp, "%x", &RegAddress);
    pTmp = (char*)parm[1].value;
    sscanf(pTmp , "%x", &RegValue);
    printf("cmd_PLT_RegisterWrite %x %x\n", RegAddress, RegValue);

    /*Call the API function */
    Status = TI_PLT_WriteRegister(g_id_adapter, RegAddress, RegValue );
    if (Status == OK)
        console_printf_terminal("Plt register 0x%x is set to 0x%x OK.\n", RegAddress, RegValue);
    else
        console_printf_terminal("Plt register 0x%x is set to 0x%x NOK.\n", RegAddress, RegValue);

}


void cmd_PLT_TxContinues(ConParm_t parm[], U16 nParms)
{
   UINT32 Status;
   PltTxContinues_t PltTxContinues;
   if ((nParms == 0) || (nParms > 10))
   {
      console_printf_terminal("\n");
	  console_printf_terminal("Param 0 - Band (0 - 2.4Ghz(B/G), 1 - 5Ghz(A), 2 - Japan(4.9Ghz))\n");
	  console_printf_terminal("Param 1 - Channel: (1..14(2.4Ghz), 1..180(5Ghz)) \n");
	  console_printf_terminal("Param 2 - Rate: \n");
      console_printf_terminal("                1  - 1Mbps\n");
      console_printf_terminal("                2  - 2Mbps\n");
      console_printf_terminal("                3  - 5.5Mbps\n");
      console_printf_terminal("                4  - 11Mbps\n");
      console_printf_terminal("                6  - 6Mbps\n");
      console_printf_terminal("                7  - 9Mbps\n");
      console_printf_terminal("                8  - 12Mbps\n");
      console_printf_terminal("                9  - 18Mbps\n");
      console_printf_terminal("                10 - 24Mbps\n");
      console_printf_terminal("                11 - 36Mbps\n");
      console_printf_terminal("                12 - 48Mbps\n");
      console_printf_terminal("                13 - 54Mbps \n");
	  console_printf_terminal("Param 3 - preamble (0-long, 1-short)\n");
	  console_printf_terminal("Param 4 - Delay between packets (uSec)\n");
      console_printf_terminal("Param 5 - Number of TX frames (0 - endless)\n");
      console_printf_terminal("Param 6 - Test mode (5-Random data, 9-ZOZO(0,1,0,1,...))\n");
      console_printf_terminal("Param 7 - Sequance number mode(0 - fixed, 1 - incremented)\n");
      console_printf_terminal("Param 8 - packet Data legth [bytes] (0 - 2284)\n");
      console_printf_terminal("Param 9 - peer mac address: [xx:xx:xx:xx:xx:xx]\n");

   }
   else
   {
	   PltTxContinues.band 	            = (UINT8) parm[0].value;
	   PltTxContinues.chID   	        = parm[1].value;
	   PltTxContinues.rate   	        = parm[2].value;
	   PltTxContinues.preamble	        = (UINT8) parm[3].value;
	   PltTxContinues.InterPacketDelay  = parm[4].value;
       PltTxContinues.NumOfFrames       = parm[5].value;
	   PltTxContinues.mode              = (UINT8) parm[6].value;
       PltTxContinues.aSeqNumMode       = parm[7].value;
       PltTxContinues.aPacketLength     = parm[8].value;
       hexStr2MACAddr( (char*)parm[9].value, &(PltTxContinues.aPeerMacAddr) );


	   Status = TI_PLT_TxContiues(g_id_adapter, &PltTxContinues);
		if (Status == OK)
			console_printf_terminal("OK\n");
		else
			console_printf_terminal("NOK\n");

   }
}

void cmd_PLT_TxCW(ConParm_t parm[], U16 nParms)
{
   UINT32 Status;
   TestCmdChannelBand_t PltTxCW;

   if ((nParms == 0) || (nParms > 2))
   {
	  console_printf_terminal("Param 0 - Band (0 - 2.4Ghz(B/G), 1 - 5Ghz(A), 2 - Japan(4.9Ghz))\n");
	  console_printf_terminal("Param 1 - Channel(1..14(2.4Ghz), 1..180(5Ghz))\n");
   }
   else
   {
	   PltTxCW.band 	= (RadioBand_e) parm[0].value;
	   PltTxCW.channel 	= (Channel_e) parm[1].value;

	   Status = TI_PLT_TxCW(g_id_adapter, &PltTxCW);
		if (Status == OK)
			console_printf_terminal("OK\n");
		else
			console_printf_terminal("NOK\n");

   }
}

void cmd_PLT_TxStop(ConParm_t parm[], U16 nParms)
{
	UINT32 Status = TI_PLT_TxStop(g_id_adapter);
	if (Status == OK)
		console_printf_terminal("OK\n");
	else
		console_printf_terminal("NOK\n");
}

void cmd_PLT_MIB_CounterTable(ConParm_t parm[], U16 nParms)
{
    PLT_MIB_t Mib;
    UINT32 Status;
    memset(&Mib, 0, sizeof(Mib));
    Mib.aMib = PLT_MIB_countersTable;

    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
    if (Status == OK)
    {
       console_printf_terminal("FCS error count= %d \nPLCP  error count = %d\n",
							   Mib.aData.CounterTable.FCSErrorCount,
							   Mib.aData.CounterTable.PLCPErrorCount);
    }
    else
    {
		console_printf_terminal("NOK\n");
    }
}

void cmd_PLT_MIB_StationID(ConParm_t parm[], U16 nParms)
{
    PLT_MIB_t Mib;
    UINT32 Status;
    memset(&Mib, 0, sizeof(Mib));
    Mib.aMib = PLT_MIB_dot11StationId;

    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
    if (Status == OK)
    {
       console_printf_terminal("MIB_StationID = %02x:%02x:%02x:%02x:%02x:%02x\n",
                                Mib.aData.StationId.addr[5],
                                Mib.aData.StationId.addr[4],
                                Mib.aData.StationId.addr[3],
                                Mib.aData.StationId.addr[2],
                                Mib.aData.StationId.addr[1],
                                Mib.aData.StationId.addr[0]);
    }
    else
    {
		console_printf_terminal("NOK\n");
    }


}


void cmd_modify_ctsToSelf(ConParm_t parm[], U16 nParms)
{
    PLT_MIB_t Mib;
    UINT32 Status;
    memset(&Mib, 0, sizeof(Mib));
    Mib.aMib = PLT_MIB_ctsToSelf;

	if (nParms != 1)
	{
	   console_printf_terminal("CTS to self: [0 - Disable, 1 - Enable]\n");
	}

	if (nParms == 0) /*Get ctsToSelf */
    {
        Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
        if (OK == Status)
            console_printf_terminal("ctsToSelf = %s (%d)\n",
            Mib.aData.CTSToSelfEnable?"Enable":"Disable",
            Mib.aData.CTSToSelfEnable);
    }
    else if (nParms == 1)
    {
        Mib.Length = sizeof(Mib.aData.CTSToSelfEnable);
        Mib.aData.CTSToSelfEnable = parm[0].value;
        if (OK != TI_PLT_WriteMIB(g_id_adapter, &Mib))
            console_printf_terminal("TI_PLT_WriteMIB failed\n");
    }
}

void cmd_get_arpIpTable(ConParm_t parm[], U16 nParms)
{
    PLT_MIB_t Mib;
    UINT32 Status;
    memset(&Mib, 0, sizeof(Mib));
    Mib.aMib = PLT_MIB_arpIpAddressesTable;
    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
    if (OK == Status)
    {
       int FilteringEnable = Mib.aData.ArpIpAddressesTable.FilteringEnable;
       console_printf_terminal("ARP IP Table:\n");
       console_printf_terminal("FilteringEnable: %s (%d)\n",
           FilteringEnable?"Enable":"Disable",
           FilteringEnable);
       console_printf_terminal("ArpIpAddress: %d.%d.%d.%d\n",
           Mib.aData.ArpIpAddressesTable.addr[0],
           Mib.aData.ArpIpAddressesTable.addr[1],
           Mib.aData.ArpIpAddressesTable.addr[2],
           Mib.aData.ArpIpAddressesTable.addr[3]
           );
    }
}

void cmd_get_GroupAddressTable(ConParm_t parm[], U16 nParms)
{
    PLT_MIB_t Mib;
    UINT32 Status;
    memset(&Mib, 0, sizeof(Mib));
    Mib.aMib = PLT_MIB_dot11GroupAddressesTable;
    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
    if (OK == Status)
    {
       int FilteringEnable = Mib.aData.GroupAddressTable.bFilteringEnable;
       int i;

       console_printf_terminal("Group addresses Table:\n");
       console_printf_terminal("FilteringEnable: %s (%d)\n",
           FilteringEnable?"Enable":"Disable",
           FilteringEnable);
       console_printf_terminal("nNumberOfAddresses: %d\n", Mib.aData.GroupAddressTable.nNumberOfAddresses);
       console_printf_terminal("Group addresses: \n");

       for (i=0; i<Mib.aData.GroupAddressTable.nNumberOfAddresses; i++)
       console_printf_terminal("%x:%x:%x:%x:%x:%x\n",
           Mib.aData.GroupAddressTable.GroupTable[i].addr[0],
           Mib.aData.GroupAddressTable.GroupTable[i].addr[1],
           Mib.aData.GroupAddressTable.GroupTable[i].addr[2],
           Mib.aData.GroupAddressTable.GroupTable[i].addr[3],
           Mib.aData.GroupAddressTable.GroupTable[i].addr[4],
           Mib.aData.GroupAddressTable.GroupTable[i].addr[5]
           );
    }
}

void cmd_PLT_TxCalGainGet(ConParm_t parm[], U16 nParms)
{
   UINT32 Status;
   PltGainGet_t PLTGainGet;

   Status = TI_PLT_TxCalGainGet(g_id_adapter, &PLTGainGet);
   if (Status == OK)
   {
       console_printf_terminal("\n");
       console_printf_terminal("TxGain: %d(0x%x)\n", PLTGainGet.TxGain, PLTGainGet.TxGain);
       console_printf_terminal("TxUpperBound: %d(0x%x)\n", PLTGainGet.TxUpperBound, PLTGainGet.TxUpperBound);
       console_printf_terminal("TxLowerBound: %d(0x%x)\n", PLTGainGet.TxLowerBound, PLTGainGet.TxLowerBound);
   }
   else
       console_printf_terminal("NOK\n");
}


void cmd_PLT_TxCalGainAdjust(ConParm_t parm[], U16 nParms)
{
   UINT32 Status;
   UINT32 GainChange;
   OS_802_11_POWER_LEVELS mode;


   if ((nParms == 0) || (nParms > 1))
   {
	   console_printf_terminal("\n");
       console_printf_terminal("Param 0 - Gain change (db)\n");
   }
   else
   {
       GainChange = parm[0].value;

        /* Check Power mode (works only in "awake" mode !!!) */
        TI_GetPowerLevelDefault(g_id_adapter, &mode );
        if(mode == OS_POWER_LEVEL_AWAKE)
        {
	   Status = TI_PLT_TxCalGainAdjust(g_id_adapter, GainChange);
		    if (Status == OK)
			    console_printf_terminal("OK\n");
		    else
			    console_printf_terminal("NOK\n");
        }
        else
        {
	        console_printf_terminal("Gain Adjust was not performed becouse Default power-mode is not AWAKE\n");
	        console_printf_terminal("Please change defaultPowerLevel parametr in tiwlan.ini file first\n");
        }
   }
}

void cmd_PLT_TxCalStart(ConParm_t parm[], U16 nParms)
{
       UINT32 Status;
	   PltTxCalibrationRequest_t tTxStart;

	   if (nParms != 1)
	   {
		   console_printf_terminal("\nParam 0 - Tx Power [0-255]\n");
	   }
	   else
	   {
        /* use U8 cast to fix compile warning */
		   tTxStart.refTxPower = (U8)parm[0].value;
		   Status = TI_PLT_TxCalStart(g_id_adapter,&tTxStart);
		   if (Status == OK)
			   console_printf_terminal("OK\n");
		   else
			   console_printf_terminal("NOK\n");
	   }
}

void cmd_PLT_TxCalStop(ConParm_t parm[], U16 nParms)
{
       UINT32 Status;

	   Status = TI_PLT_TxCalStop(g_id_adapter);
       if (Status == OK)
           console_printf_terminal("OK\n");
       else
           console_printf_terminal("NOK\n");
}

void cmd_PLT_RxTxCalNVSUpdateBuffer(ConParm_t parm[], U16 nParms)
{
   UINT32 Status;
   PltNvsResultsBuffer_t PltNvsResultsBuffer;
   int i;

   memset(&PltNvsResultsBuffer, 0, sizeof(PltNvsResultsBuffer));
   Status = TI_PLT_RxTxCalNVSUpdateBuffer(g_id_adapter, &PltNvsResultsBuffer);
   if (Status == OK)
   {
       console_printf_terminal("NVSUpdateBuffer -  number of tables:%d\n", PltNvsResultsBuffer.numOfTables);
       console_printf_terminal("# \t Offset\t Size\t Data\n");
       console_printf_terminal("###################################################################\n");
       for (i=0; (i<PltNvsResultsBuffer.numOfTables) && (i<NVS_RESULTS_MAX_NUM_OF_TABLES); i++)
       {
        int j;
        console_printf_terminal("#%d\t %p\t %.4d\t ",
                                i,
                                PltNvsResultsBuffer.tables[i].offset,
                                PltNvsResultsBuffer.tables[i].size);
        for (j=0; (j<PltNvsResultsBuffer.tables[i].size) && (j<NVS_RESULTS_MAX_UPDATE_TABLE_SIZE); j++)
        {
            console_printf_terminal("%.2x ", PltNvsResultsBuffer.tables[i].data[j]);
        }
        console_printf_terminal("\n");
       }
   }
   else
       console_printf_terminal("NOK\n");
}

void cmd_PLT_RxCal(ConParm_t parm[], U16 nParms)
{
   UINT32 Status;
   PltRxCalibrationRequest_t PltRxCalibrationRequest;
   OS_802_11_POWER_LEVELS mode;

   if ((nParms == 0) || (nParms > 5))
   {
      console_printf_terminal("\n");
	  console_printf_terminal("Param 0 - Expected Rssi (db)\n");
	  console_printf_terminal("Param 1 - Channel\n");
	  console_printf_terminal("Param 2 - Band (0 - 2.4Ghz(B/G), 1 - 5Ghz(A), 2 - Japan(4.9Ghz)\n");
      console_printf_terminal("Param 3 - Interval between samples(uSec) [100]\n");
      console_printf_terminal("Param 4 - Number of samples [1000]\n");
   }
   else
   {
	   PltRxCalibrationRequest.expectedRssi	= parm[0].value;
	   PltRxCalibrationRequest.channel = (UINT8)parm[1].value;
	   PltRxCalibrationRequest.band = (UINT8)parm[2].value;
       PltRxCalibrationRequest.intervalBetweenSamplesUsec = parm[3].value;
       PltRxCalibrationRequest.numOfSamples = (UINT16)parm[4].value;

        /* Check Power mode (works only in "awake" mode !!!) */
        TI_GetPowerLevelDefault(g_id_adapter, &mode );
        if(mode == OS_POWER_LEVEL_AWAKE)
        {
	        Status = TI_PLT_RxCal(g_id_adapter, &PltRxCalibrationRequest);
	        if (Status == OK)
		        console_printf_terminal("OK\n");
	        else
		        console_printf_terminal("NOK\n");
        }
        else
        {
	        console_printf_terminal("Rx calibration was not performed becouse Default power-mode is not AWAKE\n");
	        console_printf_terminal("Please change defaultPowerLevel parametr in tiwlan.ini file first\n");
        }
   }
}

void cmd_PLT_RadioTune(ConParm_t parm[], U16 nParms)
{
   UINT32 Status;
   TestCmdChannelBand_t ChannelBand;
   OS_802_11_POWER_LEVELS mode;


   if ((nParms == 0) || (nParms > 2))
   {
	  console_printf_terminal("Param 0 - Band (0-2.4Ghz, 1-5Ghz, 2-4.9Ghz)\n");
	  console_printf_terminal("Param 1 - Channel\n");
   }
   else
   {
	   ChannelBand.band 	= (RadioBand_e) parm[0].value;
	   ChannelBand.channel 	= (Channel_e) parm[1].value;

	    /* Check Power mode (works only in "awake" mode !!!) */
        TI_GetPowerLevelDefault(g_id_adapter, &mode );
		if(mode == OS_POWER_LEVEL_AWAKE)
		{
			Status = TI_PLT_RadioTune(g_id_adapter, &ChannelBand);
			if (Status == OK)
				console_printf_terminal("OK\n");
			else
				console_printf_terminal("NOK\n");
		}
		else
		{
			console_printf_terminal("Radio tune was not performed becouse Default power-mode is not AWAKE\n");
			console_printf_terminal("Please change defaultPowerLevel parametr in tiwlan.ini file first\n");
		}
	}
}


#ifdef _WINDOWS
#endif /* ifdef _WINDOWS */