1/*******************************************************************************
2**+--------------------------------------------------------------------------+**
3**|                                                                          |**
4**| Copyright 1998-2008 Texas Instruments, Inc. - http://www.ti.com/         |**
5**|                                                                          |**
6**| Licensed under the Apache License, Version 2.0 (the "License");          |**
7**| you may not use this file except in compliance with the License.         |**
8**| You may obtain a copy of the License at                                  |**
9**|                                                                          |**
10**|     http://www.apache.org/licenses/LICENSE-2.0                           |**
11**|                                                                          |**
12**| Unless required by applicable law or agreed to in writing, software      |**
13**| distributed under the License is distributed on an "AS IS" BASIS,        |**
14**| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |**
15**| See the License for the specific language governing permissions and      |**
16**| limitations under the License.                                           |**
17**|                                                                          |**
18**+--------------------------------------------------------------------------+**
19*******************************************************************************/
20
21#ifdef _WINDOWS
22#endif
23
24#include <stdio.h>
25#include <string.h>
26#include <stdlib.h>
27#include <ctype.h>
28
29#ifndef _WINDOWS
30	#include <errno.h>
31#include <stdio.h>
32#include <unistd.h>
33#include <termios.h>
34#include <sys/socket.h>
35#include <linux/if.h>
36#include <linux/wireless.h>
37
38	#include "tnetwCommon.h"
39#endif /* __LINUX__ */
40
41#include "g_tester.h"
42#include "wspVer.h"
43
44#include "paramOut.h"
45#include "console.h"
46#include "ticon.h"
47#include "cu_cmd.h"
48#include "linux_ioctl_common.h"
49#include "802_11Defs.h"
50
51#ifndef _T
52#define _T(a)    a
53#endif
54
55#ifndef _WINDOWS
56TI_HANDLE   g_id_adapter = 0;
57#endif
58
59#define MAX_SSID_LEN 32
60#define CLI_NUM_OF_TX_CLASFR_CON 4
61
62scan_Params_t appScanParams;
63scan_Policy_t scanPolicy;
64
65/*** Roaming Manager configuration parameters ***/
66roamingMngrConfigParams_t   roamingMngrConfigParams;
67
68static tiUINT32 events_mask = 0; // TRS:PGK
69
70#define NET_BASIC_MASK      0x80    /* defined in common/src/utils/utils.c */
71
72#define IS_BASIC_RATE(a)    ((a) & NET_BASIC_MASK)
73
74#define RATE_2_MBPS(a)    ((float)((a) & (NET_BASIC_MASK-1))/2)
75
76#define GET_NAME_BY_VALUE(arr, value)    get_name_by_value(arr, SIZE_ARR(arr), value)
77
78#define CHAN_FREQ_TABLE_SIZE        (sizeof(ChanFreq) / sizeof(struct CHAN_FREQ))
79
80#define RATE_TABLE_SIZE             (sizeof(rate2Str) / sizeof(named_value_t))
81
82#define ET_TABLE_SIZE               (sizeof(EtEvent2Str) / sizeof(named_value_t))
83
84/* EarlyTermination DISABLE mode - Should be same as in scan.h */
85#define SCAN_ET_COND_DISABLE 0
86
87#define MAX_PSK_STRING_LENGTH       63
88
89#define MIN_PSK_STRING_LENGTH       8
90
91#define PSK_HEXA_LENGTH       64
92
93#define PSK_BUFF_LEN 65
94
95static void get_bssid_list(ConParm_t parm[], U16 nParms, BOOL fullBssidList , OS_802_11_BSSID_EX *pBssid);
96
97static BOOL is_value_rate (tiUINT32 rate)
98{
99
100   switch (rate)
101   {
102   case 1:
103   case 2:
104   case 5:
105   case 6:
106   case 9:
107   case 11:
108   case 12:
109   case 18:
110   case 22:
111   case 24:
112   case 36:
113   case 48:
114   case 54:
115      return (TRUE);
116   default:
117      return (FALSE);
118   }
119
120}
121static BOOL is_value_rate (tiUINT32 rate);
122struct CHAN_FREQ {
123    UINT8       chan;
124    UINT32      freq;
125} ChanFreq[] = {
126    {1,2412000}, {2,2417000}, {3,2422000}, {4,2427000},
127    {5,2432000}, {6,2437000}, {7,2442000}, {8,2447000},
128    {9,2452000},
129    {10,2457000}, {11,2462000}, {12,2467000}, {13,2472000},
130    {14,2484000}, {36,5180000}, {40,5200000}, {44,5220000},
131    {48,5240000}, {52,5260000}, {56,5280000}, {60,5300000},
132    {64,5320000},
133    {100,5500000}, {104,5520000}, {108,5540000}, {112,5560000},
134    {116,5580000}, {120,5600000}, {124,5620000}, {128,5640000},
135    {132,5660000}, {136,5680000}, {140,5700000}, {149,5745000},
136    {153,5765000}, {157,5785000}, {161,5805000} };
137
138static named_value_t power_mode_val[] = {
139        { OS_POWER_MODE_AUTO,        "AUTO" },
140        { OS_POWER_MODE_ACTIVE,      "ACTIVE" },
141        { OS_POWER_MODE_SHORT_DOZE,  "SHORT_DOZE" },
142        { OS_POWER_MODE_LONG_DOZE,   "LONG_DOZE" }
143};
144
145static named_value_t power_level_val[] = {
146        { OS_POWER_LEVEL_ELP,        "ELP" },
147        { OS_POWER_LEVEL_PD,      "PD" },
148        { OS_POWER_LEVEL_AWAKE,  "AWAKE" }
149};
150
151static named_value_t encrypt_type[] = {
152        { OS_ENCRYPTION_TYPE_NONE,              "None" },
153        { OS_ENCRYPTION_TYPE_WEP,               "WEP"  },
154        { OS_ENCRYPTION_TYPE_TKIP,              "TKIP" },
155        { OS_ENCRYPTION_TYPE_AES,               "AES" }
156};
157
158static named_value_t scanType2Str[] = {
159        { SCAN_TYPE_NORMAL_PASSIVE,             "Passive Normal Scan"               },
160        { SCAN_TYPE_NORMAL_ACTIVE,              "Active Normal Scan"                },
161        { SCAN_TYPE_SPS,                        "Scheduled Passive Scan (SPS)"      },
162        { SCAN_TYPE_TRIGGERED_PASSIVE,          "Passive Triggered Scan"            },
163        { SCAN_TYPE_TRIGGERED_ACTIVE,           "Active Triggered Scan"             }
164};
165
166static named_value_t band2Str[] = {
167        { RADIO_BAND_2_4_GHZ,                   "2.4 GHz"                        },
168        { RADIO_BAND_5_0_GHZ,                   "5.0 GHz"                        },
169        { RADIO_BAND_DUAL,                      "Both   "                        }
170};
171
172static named_value_t rate2Str[] = {
173        { DRV_RATE_MASK_AUTO,                   "Auto    "                          },
174        { DRV_RATE_MASK_1_BARKER,               "1 Mbps  "                          },
175        { DRV_RATE_MASK_2_BARKER,               "2 Mbps  "                          },
176        { DRV_RATE_MASK_5_5_CCK,                "5.5 Mbps"                          },
177        { DRV_RATE_MASK_11_CCK,                 "11 Mbps "                          },
178        { DRV_RATE_MASK_22_PBCC,                "22 Mbps "                          },
179        { DRV_RATE_MASK_6_OFDM,                 "6 Mbps  "                          },
180        { DRV_RATE_MASK_9_OFDM,                 "9 Mbps  "                          },
181        { DRV_RATE_MASK_12_OFDM,                "12 Mbps "                          },
182        { DRV_RATE_MASK_18_OFDM,                "18 Mbps "                          },
183        { DRV_RATE_MASK_24_OFDM,                "24 Mbps "                          },
184        { DRV_RATE_MASK_36_OFDM,                "36 Mbps "                          },
185        { DRV_RATE_MASK_48_OFDM,                "48 Mbps "                          },
186        { DRV_RATE_MASK_54_OFDM,                "54 Mbps "                          }
187};
188
189static named_value_t EtEvent2Str[] = {
190        { SCAN_ET_COND_DISABLE,                      "ET disabled  "                     },
191        { SCAN_ET_COND_BEACON,                       "ET on Beacon "                     },
192        { SCAN_ET_COND_PROBE_RESP,                   "ET on Prb Rsp"                     },
193        { SCAN_ET_COND_ANY_FRAME,                    "ET on both   "                     }
194};
195
196/* used in scan_display */
197static char* rate2StrFunc(UINT32 rate)
198{
199    UINT32 i;
200
201    for ( i = 0; i < RATE_TABLE_SIZE; i++ )
202    {
203        if ( rate2Str[ i ].value == rate )
204            return rate2Str[ i ].name;
205    }
206    return rate2Str[ 0 ].name;
207}
208
209/* used in scan_display */
210static char* EtEvent2StrFunc( UINT32 ETCond )
211{
212    int i;
213
214    for ( i = 0; i < ET_TABLE_SIZE; i++ )
215    {
216        if ( EtEvent2Str[ i ].value == ETCond )
217        {
218            return EtEvent2Str[ i ].name;
219        }
220    }
221
222    return EtEvent2Str[ 0 ].name;
223}
224
225/* used in get_bssid_list() */
226UINT8 Freq2Chan(UINT32 freq)
227{
228    UINT32 i;
229
230    for(i=0; i<CHAN_FREQ_TABLE_SIZE; i++)
231        if(ChanFreq[i].freq == freq) return ChanFreq[i].chan;
232
233    return 0;
234}
235/* IPC events Callback */
236int cli_receive_ev(IPC_EV_DATA*    pData)
237{
238    tiUINT8 *buf;
239    OS_802_11_QOS_TSPEC_PARAMS *AddTsResult;
240    OS_802_11_AUTHENTICATION_REQUEST *request;
241	OS_802_11_DISASSOCIATE_REASON_T	 *pDisAssoc;
242    OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS *CrossParams;
243    OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_CROSS_INDICATION_PARAMS *TrafficIntensityThresholdParams;
244	btCoexStatus_t				*btCoexStatus;
245
246#if defined (_WINDOWS)
247#endif
248    g_tester_receive_event((tiUINT8)((IPC_EVENT_PARAMS *)pData)->uEventType);
249#if defined (_WINDOWS)
250#endif
251
252    switch(((IPC_EVENT_PARAMS *)pData)->uEventType)
253    {
254        case IPC_EVENT_ASSOCIATED:
255            console_printf_terminal("CLI Event - Associated\n");
256// TRS:HLC
257/*
258#if defined (_WINDOWS)
259#endif
260*/
261//TRS end
262        break;
263        case IPC_EVENT_DISASSOCIATED:
264			pDisAssoc = (OS_802_11_DISASSOCIATE_REASON_T*)pData->uBuffer;
265			switch(pDisAssoc->eDisAssocType)
266			{
267			case OS_DISASSOC_STATUS_UNSPECIFIED:
268				console_printf_terminal("CLI Event - Disassociated with unspecified reason (User/SG/Recovery)\n");
269				break;
270			case OS_DISASSOC_STATUS_AUTH_REJECT:
271				if (pDisAssoc->uStatusCode == STATUS_PACKET_REJ_TIMEOUT)
272				{
273					console_printf_terminal("CLI Event - Disassociated due to no Auth response \n");
274				}
275				else
276				{
277					console_printf_terminal("CLI Event - Disassociated due to Auth response packet with reason = %d\n", pDisAssoc->uStatusCode);
278				}
279				break;
280			case OS_DISASSOC_STATUS_ASSOC_REJECT:
281				if (pDisAssoc->uStatusCode == STATUS_PACKET_REJ_TIMEOUT)
282				{
283					console_printf_terminal("CLI Event - Disassociated due to no Assoc response \n");
284				}
285				else
286				{
287					console_printf_terminal("CLI Event - Disassociated due to Assoc response packet with reason = %d\n", pDisAssoc->uStatusCode);
288				}
289			    break;
290			case OS_DISASSOC_STATUS_SECURITY_FAILURE:
291				console_printf_terminal("CLI Event - Disassociated due to RSN failure\n");
292			    break;
293			case OS_DISASSOC_STATUS_AP_DEAUTHENTICATE:
294				console_printf_terminal("CLI Event - Disassociated due to AP deAuthenticate packet with reason = %d\n", pDisAssoc->uStatusCode);
295				break;
296			case OS_DISASSOC_STATUS_AP_DISASSOCIATE:
297				console_printf_terminal("CLI Event - Disassociated due to AP disAssoc packet with reason = %d\n", pDisAssoc->uStatusCode);
298				break;
299			case OS_DISASSOC_STATUS_ROAMING_TRIGGER:
300				console_printf_terminal("CLI Event - Disassociated due to roaming trigger = %d\n", pDisAssoc->uStatusCode);
301				break;
302			default:
303				console_printf_terminal("CLI Event - Disassociated with unknown reason = %d\n", pDisAssoc->eDisAssocType);
304			    break;
305			}
306        break;
307        case IPC_EVENT_LINK_SPEED:
308            console_printf_terminal("CLI Event - LinkSpeed\n");
309        break;
310        case IPC_EVENT_AUTH_SUCC:
311            console_printf_terminal("CLI Event - Authentication Success\n");
312        break;
313        case IPC_EVENT_SCAN_COMPLETE:
314            console_printf_terminal("CLI Event - Scan Complete\n");
315        break;
316        case IPC_EVENT_TIMEOUT:
317            console_printf_terminal("CLI Event - Timeout\n");
318        break;
319        case IPC_EVENT_UNBOUND:
320            console_printf_terminal("CLI Event - Unbound\n");
321        break;
322        case IPC_EVENT_BOUND:
323            console_printf_terminal("CLI Event - Bound\n");
324        break;
325        case IPC_EVENT_EAPOL:
326            console_printf_terminal("CLI Event - EAPOL\n");
327        break;
328        case IPC_EVENT_MEDIA_SPECIFIC:
329            buf = pData->uBuffer;
330            request = (OS_802_11_AUTHENTICATION_REQUEST *) (buf + sizeof(tiUINT32));
331            if( request->Flags == OS_802_11_REQUEST_PAIRWISE_ERROR ||
332                request->Flags == OS_802_11_REQUEST_GROUP_ERROR)
333            console_printf_terminal("CLI Event - Media_Specific\n");
334        break;
335        case IPC_EVENT_CCKM_START:
336            console_printf_terminal("CLI Event - CCKM_Start\n");
337        break;
338
339        case IPC_EVENT_PREAUTH_EAPOL:
340            console_printf_terminal("CLI Event - PreAuth EAPOL\n");
341            break;
342
343        case IPC_EVENT_LOW_SNR:
344            console_printf_terminal("CLI Event - Low SNR\n");
345            break;
346
347        case IPC_EVENT_LOW_RSSI:
348            console_printf_terminal("CLI Event - Low RSSI\n");
349            break;
350
351        case IPC_EVENT_EAP_AUTH_FAILURE:
352            {
353                OS_802_11_EAP_TYPES eapType;
354                tiINT32             status;
355                authStatus_e        eAuthStatusReason;
356
357				/* Cast the value to be UINT16 16 bits since it is sent this way in the EXCMngr.c */
358                eAuthStatusReason = (authStatus_e)((*(pData->uBuffer)) & 0xFFFF);
359
360                status = TI_GetEAPType( g_id_adapter, &eapType );
361
362                if (eapType == OS_EAP_TYPE_LEAP)
363                {
364                    console_printf_terminal("CLI Event - LEAP Authentication Failed \n");
365                }
366                else if (eapType == OS_EAP_TYPE_FAST)
367                {
368                    console_printf_terminal("CLI Event - EAP-FAST Authentication Failed \n");
369                }
370                else if (eapType == OS_EAP_TYPE_TLS)
371                {
372                    console_printf_terminal("CLI Event - EAP-TLS Authentication Failed \n");
373                }
374
375                switch ( eAuthStatusReason )
376                {
377                case RSN_AUTH_STATUS_INVALID_TYPE:
378                    console_printf_terminal("The reason: Invalid Authentication Type \n");
379                    break;
380                case RSN_AUTH_STATUS_TIMEOUT:
381                    console_printf_terminal("The reason: Authentication Timeout \n");
382                    break;
383                case RSN_AUTH_STATUS_CHALLENGE_FROM_AP_FAILED:
384                case RSN_AUTH_STATUS_CHALLENGE_TO_AP_FAILED:
385                    console_printf_terminal("The reason: username or password incorrect \n");
386                    break;
387                default:
388                    console_printf_terminal("The reason: unknown = %d \n", eAuthStatusReason);
389                    break;
390                }
391
392            }
393            break;
394
395        case IPC_EVENT_TSPEC_STATUS:
396           AddTsResult = (OS_802_11_QOS_TSPEC_PARAMS *)pData->uBuffer;
397           console_printf_terminal("CLI Event - IPC_EVENT_TSPEC_STATUS -- (userPriority = %d, ReasonCode = %d) \n",AddTsResult->uUserPriority,AddTsResult->uReasonCode);
398           console_printf_terminal ("Tspec Parameters (as received through event handler):\n");
399           console_printf_terminal ("-----------------------------------------------------\n");
400           console_printf_terminal ("userPriority = %d\n",AddTsResult->uUserPriority);
401           console_printf_terminal ("uNominalMSDUsize = %d\n",AddTsResult->uNominalMSDUsize);
402           console_printf_terminal ("uMeanDataRate = %d\n",AddTsResult->uMeanDataRate);
403           console_printf_terminal ("uMinimumPHYRate = %d\n",AddTsResult->uMinimumPHYRate);
404           console_printf_terminal ("uSurplusBandwidthAllowance = %d\n",AddTsResult->uSurplusBandwidthAllowance);
405           console_printf_terminal ("uAPSDFlag = %d\n",AddTsResult->uAPSDFlag);
406           console_printf_terminal ("uMediumTime = %d\n\n",AddTsResult->uMediumTime);
407           break;
408        case IPC_EVENT_TSPEC_RATE_STATUS:
409           CrossParams = (OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS *)pData->uBuffer;
410           console_printf_terminal("CLI Event - IPC_EVENT_TSPEC_RATE_STATUS (AC = %d, HighLowFlag = %d, AboveOrBelow = %d)\n",CrossParams->uAC,CrossParams->uHighOrLowThresholdFlag,CrossParams->uAboveOrBelowFlag);
411           break;
412        case IPC_EVENT_MEDIUM_TIME_CROSS:
413           CrossParams = (OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS *)pData->uBuffer;
414           console_printf_terminal("CLI Event - IPC_EVENT_MEDIUM_TIME_CROSS (AC = %d, HighLowFlag = %d, AboveOrBelow = %d)\n",CrossParams->uAC,CrossParams->uHighOrLowThresholdFlag,CrossParams->uAboveOrBelowFlag);
415           break;
416        case IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED:
417           TrafficIntensityThresholdParams = (OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_CROSS_INDICATION_PARAMS*)pData->uBuffer;
418           printf("CLI Event - IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED\n");
419           printf("---------------------------------------------------------\n");
420           printf("Threshold crossed: %s Threshold\n", ((TrafficIntensityThresholdParams->uHighOrLowThresholdFlag == HIGH_THRESHOLD_CROSS) ? "High" : "Low"));
421           printf("Direction crossed: %s\n\n", ((TrafficIntensityThresholdParams->uAboveOrBelowFlag == CROSS_ABOVE) ? "Above" : "Below"));
422           break;
423
424        case IPC_EVENT_WPA2_PREAUTHENTICATION:
425            {
426                ULONG *WPA2_PreAuth_Status;
427
428               WPA2_PreAuth_Status = (ULONG *)pData->uBuffer;
429               printf("CLI Event - IPC_EVENT_WPA2_PREAUTHENTICATION\n");
430               printf("Status code = %lu\n",*WPA2_PreAuth_Status);
431            }
432           break;
433
434        case IPC_EVENT_ROAMING_COMPLETE:
435            printf("CLI Event - IPC_EVENT_ROAMING_COMPLETE \n");
436        break;
437
438	case IPC_EVENT_BT_COEX_MODE:
439		btCoexStatus = (btCoexStatus_t*)pData->uBuffer;
440		if (btCoexStatus->state)
441		{
442			console_printf_terminal("CLI Event - IPC_EVENT_BT_COEX_MODE (SG is ON, minTxRate = %d)\n",btCoexStatus->minTxRate);
443		}
444		else
445		{
446			console_printf_terminal("CLI Event - IPC_EVENT_BT_COEX_MODE (SG is OFF)\n");
447		}
448		break;
449
450        default:
451            console_printf_terminal("CLI Event - Unknown event\n");
452        break;
453    }
454    return 0;
455
456
457}
458
459static char *print_rate(rate_e rate)
460{
461    static char buf[20];
462
463    if( rate == 0 )
464        return "Auto (0)";
465
466    sprintf(buf, "%.3g Mbps (%u%s)", RATE_2_MBPS(rate), rate,
467        IS_BASIC_RATE(rate) ? " - basic" : "" );
468    return buf;
469}
470
471static BOOL isJunkSSID(OS_802_11_SSID *ssid )
472{
473    if ((ssid == NULL) || (ssid->SsidLength == 0))
474    {
475        return TRUE;
476    }
477
478    if (ssid->SsidLength > 2)
479    {
480        if ((ssid->Ssid[0] < MAX_SSID_LEN) &&
481            (ssid->Ssid[1] < MAX_SSID_LEN) &&
482            (ssid->Ssid[2] < MAX_SSID_LEN))
483        {
484            return TRUE;
485        }
486    }
487
488    return FALSE;
489}
490
491static char *get_ssid_string(OS_802_11_SSID *ssid )
492{
493    static char tmp_buf[MAX_SSID_LEN+1];
494    if ((ssid == NULL) || (ssid->SsidLength == 0) || isJunkSSID(ssid))
495        return "<empty>";
496
497    if (ssid->SsidLength < SIZE_ARR(ssid->Ssid))
498           ssid->Ssid[ssid->SsidLength] = 0;
499    else if( ssid->SsidLength == MAX_SSID_LEN )
500    {
501        memcpy(tmp_buf, ssid->Ssid, MAX_SSID_LEN );
502        tmp_buf[MAX_SSID_LEN] = 0;
503        return tmp_buf;
504    }
505    else
506    {
507        console_printf_terminal("error: invalid ssid length (len = %u)\n", ssid->SsidLength );
508        return "<error>";
509    }
510    return (char *) ssid->Ssid;
511}
512/*  return 0 on error
513    or 'mac' if success
514    'str' format: num.num.num.num.num.num (where 'num' is number from 0 to 255)
515*/
516U8* str2MACAddr(char *str, U8 *mac)
517{
518    const int mac_len = 6;
519    int i;
520    char *p = str;
521#ifndef _WINDOWS
522    errno = 0;
523#endif
524    console_printf_terminal("str2MAC():");
525    for( i=0; i<mac_len; i++ )
526    {
527        mac[i] = (U8) strtoul(p, &p, 16);
528#ifndef _WINDOWS
529        if( errno == ERANGE )
530            return NULL;
531#endif
532        console_printf_terminal("%2x.", mac[i] );
533        p++;
534
535    }
536    console_printf_terminal("\n");
537    return mac;
538}
539
540static char * print_mac_2_str(OS_802_11_MAC_ADDRESS mac)
541{
542    static char buf[30];
543
544    sprintf(buf, "%02x.%02x.%02x.%02x.%02x.%02x",
545                mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
546
547    return buf;
548}
549
550/* convert hex MAC addr in the form xx:xx:xx:xx:xx:xx to mac address */
551static void hexStr2MACAddr( char *hexStr, macAddress_t* mac )
552{
553    size_t i;
554    char *currHexStrPos = hexStr;
555    UINT8 tempValue;
556
557    /* convert hex string to lower */
558    for ( i = 0; i < strlen(hexStr); i++ )
559    {
560        hexStr[ i ] = tolower( hexStr[ i ] );
561    }
562
563    /* convert to numbers */
564    for ( i = 0; i < 6; i++ )
565    {
566        tempValue = 0;
567        if ( *currHexStrPos >= 'a' )
568            tempValue = *currHexStrPos - 'a' + 10;
569        else
570            tempValue = *currHexStrPos - '0';
571        currHexStrPos++;
572        tempValue <<= 4;
573        if ( *currHexStrPos >= 'a' )
574            tempValue += *currHexStrPos - 'a' + 10;
575        else
576            tempValue += *currHexStrPos - '0';
577        currHexStrPos += 2;
578        mac->addr[ i ] = tempValue;
579    }
580}
581
582static void mac2HexStr( macAddress_t* mac, char* hexStr )
583{
584    sprintf( hexStr, "%02x:%02x:%02x:%02x:%02x:%02x",
585        mac->addr[0],mac->addr[1],mac->addr[2],mac->addr[3],mac->addr[4],mac->addr[5]);
586}
587
588char *get_name_by_value(named_value_t *arr, int arr_size, UINT32 value)
589{
590    int i;
591    for(i=0; i<arr_size; i++) {
592        if( arr[i].value == value )
593            return arr[i].name;
594    }
595    return "<unknow>";
596}
597
598void cmd_modify_supported_rates(ConParm_t parm[], U16 nParms)
599{
600    rates_t data = { 0 };
601    char debug_buf[256] = { 0 };
602    int i;
603
604    if( nParms == 0 )
605    {
606        if( !TI_GetSupportedRates(g_id_adapter, (tiUINT8*)&data, sizeof(data)) )
607        {
608            console_printf_terminal(" Rates: ");
609            for( i=0; i<MAX_SUPPORTED_RATES && i < data.len; i++ )
610            {
611                console_printf_terminal("%g Mbps(%u%s)%s", RATE_2_MBPS(data.ratesString[i]),
612                    data.ratesString[i],
613                    IS_BASIC_RATE(data.ratesString[i]) ? " - basic" : "",
614                    (i < data.len-1) ? "," : "" );
615            }
616            console_printf_terminal("\n");
617        }
618    }
619    else
620    {
621        char *end_p, *buf = (char *) parm[0].value;
622        float val;
623        console_printf_terminal("param: %s\n", buf );
624#ifndef _WINDOWS
625        errno = 0;
626#endif
627        for( i=0; *buf && i < MAX_SUPPORTED_RATES; i++ )
628        {
629            val = (float) strtod(buf, &end_p);
630            if(
631#ifndef _WINDOWS
632			   errno ||
633#endif
634			   buf == end_p )
635            {
636                console_printf_terminal("cmd_modify_supported_rates(): invalid value - %s\n", buf );
637                return;
638            }
639            if( val > ((1 << (sizeof(data.ratesString[i]) * 8))-1) )
640            {
641                console_printf_terminal("cmd_modify_supported_rates(): out of range '%.*s'\n", end_p - buf, buf );
642                return;
643            }
644            data.ratesString[i] = (tiUINT8) (val);
645
646            sprintf(&debug_buf[strlen(debug_buf)], "%g (%d) ", val, data.ratesString[i] );
647
648            buf = end_p;
649            while( *buf==' ' || *buf == ',' )   buf++;
650
651        }
652
653        if( *buf )
654        {
655            console_printf_terminal("too many parameters. Max=%d\n", MAX_SUPPORTED_RATES );
656            return;
657        }
658
659        data.len = i;
660        console_printf_terminal("**set rates (%d) :%s\n", data.len, debug_buf );
661        TI_SetSupportedRates(g_id_adapter, (tiUINT8*) &data, sizeof(data));
662    }
663}
664
665void cmd_show_status(ConParm_t parm[], U16 nParms)
666{
667    tiINT32 res;
668    OS_802_11_BSSID_EX BssIdInfo;
669
670    tiUINT32 data;
671    char buf[4096] = { 0 };
672    OS_802_11_SSID ssid = { 0 };
673    OS_802_11_MAC_ADDRESS bssid = { 0 };
674
675    UNUSED(parm);
676    UNUSED(nParms);
677
678    buf[0] = 0;
679
680    res = TI_WLAN_IsDriverRun(g_id_adapter, (tiBOOL *)&data);
681    if( res )
682        return ;
683
684    sprintf(buf, "Status   : %s\n", res ? "<error>" : (data ? "running" : "stopped") );
685
686    sprintf(&buf[strlen(buf)], "MAC      : ");
687    if( !TI_GetCurrentAddress(g_id_adapter, &bssid ) )
688        strcat(buf, print_mac_2_str(bssid) );
689    else
690        strcat(buf, "<error>");
691
692    strcat(buf, "\nSSID     : ");
693    if( !TI_GetCurrentSSID(g_id_adapter, &ssid) )
694    {
695        if (!isJunkSSID(&ssid))
696        {
697           strncat(buf, get_ssid_string(&ssid),ssid.SsidLength);
698        }
699        else
700        {
701           strcat(buf,"<empty>");
702        }
703    }
704    else
705        strcat(buf, "<error>" );
706
707    sprintf(&buf[strlen(buf)], "\nBSSID    : ");
708
709   TI_GetSelectedBSSIDInfo(g_id_adapter, &BssIdInfo);
710   strcat(buf, print_mac_2_str(BssIdInfo.MacAddress));
711
712    strcat(buf, "\nChannel  : ");
713    data = 0;
714    if( !TI_GetCurrentChannel(g_id_adapter, &data ) )
715    {
716        sprintf(&buf[strlen(buf)], "%d", data );
717    }
718    else
719        strcat(buf, "<error>");
720
721    console_printf_terminal("==========================\n%s\n==========================\n\n", buf);
722}
723
724void cmd_connect(ConParm_t parm[], U16 nParms)
725{
726    char buf[1] = { 0 };
727    OS_802_11_MAC_ADDRESS bssid = { 0xff,0xff,0xff,0xff,0xff,0xff };
728
729    buf[0] = 0;
730
731    switch (nParms) {
732
733    case 0 :
734        /*
735         *  No SSID & No BSSID are set -
736         *  Use Any SSID & Any BSSID.
737         */
738
739        TI_SetBSSID(g_id_adapter, &bssid );
740        TI_SetSSID(g_id_adapter, (tiUINT8 *) buf);
741        break;
742
743    case 1:
744        /*
745         *  SSID set & BSSID insn't set  -
746         *  Use CLI's SSID & Any BSSID.
747         */
748        TI_SetBSSID(g_id_adapter, &bssid );
749        TI_SetSSID(g_id_adapter, (tiUINT8 *) parm[0].value);
750        break;
751
752    case 2:
753        /*
754         *  Both SSID & BSSID are set -
755         *  Use CLI's SSID & BSSID.
756         */
757        if( !str2MACAddr((char *) parm[1].value, bssid) )
758            return;
759        TI_SetBSSID(g_id_adapter, &bssid);
760        TI_SetSSID(g_id_adapter, (tiUINT8 *) parm[0].value);
761        break;
762}
763}
764
765
766void cmd_disassociate(ConParm_t parm[], U16 nParms)
767{
768    UNUSED(parm);
769    UNUSED(nParms);
770
771    TI_Disassociate(g_id_adapter);
772}
773
774void cmd_show_advanced_params(ConParm_t parm[], U16 nParms)
775{
776    tiUINT32 mode_4x = 0, preamble = 0xfefefefe;
777    OS_802_11_AUTHENTICATION_MODE auth;
778    OS_802_11_ENCRYPTION_TYPES encrypt;
779    tiUINT32    rts_tresh;
780    tiUINT32    frag_tresh = 0xfefefefe;
781    tiUINT8     tx_power = 0xfe;
782    OS_802_11_POWER_PROFILE power_mode = 0;
783
784    UNUSED(parm);
785    UNUSED(nParms);
786
787    TI_GetAuthenticationMode(g_id_adapter, &auth );
788    TI_GetTxPowerDbm(g_id_adapter, (tiCHAR*) &tx_power);
789    TI_GetFragmentThreshold( g_id_adapter, &frag_tresh);
790    TI_GetRTSThreshold( g_id_adapter, &rts_tresh);
791    TI_Get4XState( g_id_adapter, &mode_4x);
792    TI_GetEncryptionType( g_id_adapter, &encrypt );
793    TI_GetPowerMode(g_id_adapter, (OS_802_11_POWER_PROFILE*) &power_mode );
794    console_printf_terminal("  Authentication : %u\n", auth );
795    console_printf_terminal("      Power mode : %d\n", (tiUINT32) power_mode );
796    console_printf_terminal("  Tx Power (Dbm/10 units) : %d\n", tx_power );
797
798    console_printf_terminal("      Encryption : %u\n", encrypt );
799    console_printf_terminal("        Preamble : <%s>\n", (preamble) ? "short" : "long");
800/*    console_printf_terminal("      Tx antenna : %u\n", tx_ant );*/
801/*    console_printf_terminal(  "      Rx antenna : %u\n", rx_ant );*/
802/*    console_printf_terminal(  "Ap Tx power level: n/a\n" );*/
803/*    console_printf_terminal(  "  Tx power value : %lu\n", tx_power_val );*/
804/*    console_printf_terminal(  "     MAC address : n/a\n" );*/
805    console_printf_terminal(  "        4X state : %d\n", mode_4x );
806/*     console_printf_terminal(  "        B/G mode : n/a\n" );*/
807/*     console_printf_terminal(  "    Country code : n/a\n" );*/
808/*     console_printf_terminal(  "      IP address : n/a\n" );*/
809/*     console_printf_terminal(  "        Net mask : n/a\n" );*/
810/*     console_printf_terminal(  "         Gateway : n/a\n" );*/
811    console_printf_terminal(  " Frag. threshold : %u\n", frag_tresh);
812    console_printf_terminal(  "   RTS threshold : %u\n", rts_tresh );
813
814    console_printf_terminal(  "Power mode: ");
815    print_available_values(power_mode_val);
816
817    console_printf_terminal(  "Encryption type: ");
818    print_available_values(encrypt_type);
819}
820
821void cmd_show_statistics(ConParm_t parm[], U16 nParms)
822{
823    TIWLN_STATISTICS statistics = { 0 } ;
824
825    UNUSED(parm);
826    UNUSED(nParms);
827
828    console_printf_terminal(  "TI_GetStatistics(%s, data=%p, size=%d\n", (char*) g_id_adapter, &statistics, sizeof(statistics) );
829
830    if( TI_GetStatistics( g_id_adapter, &statistics ) )
831    {
832        console_printf_terminal ("Error in getting TI_GetStatistics!!\n");
833        return;
834    }
835
836    console_printf_terminal("******************\n");
837    console_printf_terminal("Driver Statistics:\n");
838    console_printf_terminal("******************\n");
839
840    console_printf_terminal("    dot11CurrentTxRate : %s\n", print_rate(statistics.dot11CurrentTxRate) );
841    console_printf_terminal("   dot11CurrentChannel : %d\n", statistics.dot11CurrentChannel );
842    console_printf_terminal("     currentMACAddress : %s\n", print_mac_2_str(statistics.currentMACAddress) );
843    console_printf_terminal("      dot11DesiredSSID : %s\n", get_ssid_string(&statistics.dot11DesiredSSID) );
844    console_printf_terminal("          dot11BSSType : %d\n", statistics.dot11BSSType );
845    console_printf_terminal("    AuthenticationMode : %d\n", statistics.AuthenticationMode );
846    console_printf_terminal("    bShortPreambleUsed : %d\n", statistics.bShortPreambleUsed );
847    console_printf_terminal("          RTSThreshold : %d\n", statistics.RTSThreshold );
848    console_printf_terminal("FragmentationThreshold : %d\n", statistics.FragmentationThreshold );
849    console_printf_terminal(" bDefaultWEPKeyDefined : %d\n", statistics.bDefaultWEPKeyDefined );
850    console_printf_terminal("             WEPStatus : %d\n", statistics.WEPStatus );
851    console_printf_terminal("             TxAntenna : %d\n", statistics.TxAntenna );
852    console_printf_terminal("             RxAntenna : %d\n", statistics.RxAntenna );
853    console_printf_terminal("            TxPowerDbm : %d\n", statistics.TxPowerDbm );
854    console_printf_terminal("             PowerMode : %d\n", statistics.PowerMode );
855    console_printf_terminal("               RxLevel : %d\n", statistics.RxLevel );
856
857    /**/
858    /* status & AP info*/
859    /**/
860    console_printf_terminal("            dot11State : %d\n", statistics.dot11State );
861
862    /**/
863    /* network layer statistics*/
864    /**/
865    console_printf_terminal("                RecvOk : %d\n", statistics.tiCounters.RecvOk );
866    console_printf_terminal("             RecvError : %d\n", statistics.tiCounters.RecvError );
867    console_printf_terminal("     DirectedBytesRecv : %d\n", statistics.tiCounters.DirectedBytesRecv );
868    console_printf_terminal("    DirectedFramesRecv : %d\n", statistics.tiCounters.DirectedFramesRecv );
869    console_printf_terminal("    MulticastBytesRecv : %d\n", statistics.tiCounters.MulticastBytesRecv );
870    console_printf_terminal("   MulticastFramesRecv : %d\n", statistics.tiCounters.MulticastFramesRecv );
871    console_printf_terminal("    BroadcastBytesRecv : %d\n", statistics.tiCounters.BroadcastBytesRecv );
872    console_printf_terminal("   BroadcastFramesRecv : %d\n", statistics.tiCounters.BroadcastFramesRecv );
873    console_printf_terminal("             FcsErrors : %d\n", statistics.tiCounters.FcsErrors );
874    console_printf_terminal("           BeaconsRecv : %d\n", statistics.tiCounters.BeaconsRecv );
875    console_printf_terminal("          AssocRejects : %d\n", statistics.tiCounters.AssocRejects );
876    console_printf_terminal("         AssocTimeouts : %d\n", statistics.tiCounters.AssocTimeouts );
877    console_printf_terminal("           AuthRejects : %d\n", statistics.tiCounters.AuthRejects );
878    console_printf_terminal("          AuthTimeouts : %d\n", statistics.tiCounters.AuthTimeouts );
879
880    /**/
881    /* other statistics*/
882    /**/
883    console_printf_terminal("        dwSecuritySuit : %d\n", statistics.dwSecuritySuit );
884    console_printf_terminal("       dwSecurityState : %d\n", statistics.dwSecurityState );
885    console_printf_terminal("  dwSecurityAuthStatus : %d\n", statistics.dwSecurityAuthStatus );
886    console_printf_terminal("         dwFeatureSuit : %d\n", statistics.dwFeatureSuit );
887}
888
889void cmd_show_tx_statistics(ConParm_t parm[], U16 nParms)
890{
891    TIWLN_TX_STATISTICS statistics;
892    UINT32 TxQid;
893    UINT32 AverageDelay;
894    UINT32 AverageFWDelay;
895    UINT32 AverageMacDelay;
896    tiINT32 status;
897
898    UNUSED(parm);
899    UNUSED(nParms);
900
901    console_printf_terminal("TI_GetTxStatistics(%s, data=%p, size=%d\n", (char*) g_id_adapter, &statistics, sizeof(statistics) );
902
903    /* The first parameter indicates whether to clear the statistics on read: 0 - don't clear, 1 - clear */
904    if ( 0 == nParms )
905    {
906        status = TI_GetTxStatistics( g_id_adapter, &statistics, 0 );
907    }
908    else
909    {
910        status = TI_GetTxStatistics( g_id_adapter, &statistics, parm[0].value );
911    }
912
913    if( status )
914    {
915        console_printf_terminal ("Error in getting TI_GetTxStatistics!!\n");
916        return;
917    }
918
919    console_printf_terminal("*********************\n");
920    console_printf_terminal("Tx Queues Statistics:\n");
921    console_printf_terminal("*********************\n");
922
923    for (TxQid = 0; TxQid < MAX_NUM_OF_TX_QUEUES; TxQid++)
924    {
925        console_printf_terminal("\nTx Queue %d:\n", TxQid);
926        console_printf_terminal("===========\n");
927
928        console_printf_terminal("  Total Good Frames             : %d\n", statistics.txCounters[TxQid].XmitOk );
929        console_printf_terminal("  Unicast Bytes                 : %d\n", statistics.txCounters[TxQid].DirectedBytesXmit );
930        console_printf_terminal("  Unicast Frames                : %d\n", statistics.txCounters[TxQid].DirectedFramesXmit );
931        console_printf_terminal("  Multicast Bytes               : %d\n", statistics.txCounters[TxQid].MulticastBytesXmit );
932        console_printf_terminal("  Multicast Frames              : %d\n", statistics.txCounters[TxQid].MulticastFramesXmit );
933        console_printf_terminal("  Broadcast Bytes               : %d\n", statistics.txCounters[TxQid].BroadcastBytesXmit );
934        console_printf_terminal("  Broadcast Frames              : %d\n", statistics.txCounters[TxQid].BroadcastFramesXmit );
935        console_printf_terminal("  Retry Failures                : %d\n", statistics.txCounters[TxQid].RetryFailCounter );
936        console_printf_terminal("  Tx Timeout Failures           : %d\n", statistics.txCounters[TxQid].TxTimeoutCounter );
937        console_printf_terminal("  No Link Failures              : %d\n", statistics.txCounters[TxQid].NoLinkCounter );
938        console_printf_terminal("  Other Failures                : %d\n", statistics.txCounters[TxQid].OtherFailCounter );
939        console_printf_terminal("  Max Consecutive Retry Failures : %d\n\n", statistics.txCounters[TxQid].MaxConsecutiveRetryFail );
940
941        console_printf_terminal("  Retry histogram:\n");
942        console_printf_terminal("  ----------------\n\n");
943        console_printf_terminal("  Retries: %8d %8d %8d %8d %8d %8d %8d %8d\n", 0, 1, 2, 3, 4, 5, 6, 7);
944        console_printf_terminal("  packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n",
945                                statistics.txCounters[TxQid].RetryHistogram[ 0 ],
946                                statistics.txCounters[TxQid].RetryHistogram[ 1 ],
947                                statistics.txCounters[TxQid].RetryHistogram[ 2 ],
948                                statistics.txCounters[TxQid].RetryHistogram[ 3 ],
949                                statistics.txCounters[TxQid].RetryHistogram[ 4 ],
950                                statistics.txCounters[TxQid].RetryHistogram[ 5 ],
951                                statistics.txCounters[TxQid].RetryHistogram[ 6 ],
952                                statistics.txCounters[TxQid].RetryHistogram[ 7 ]);
953        console_printf_terminal("  Retries: %8d %8d %8d %8d %8d %8d %8d %8d\n", 8, 9, 10, 11, 12, 13, 14, 15);
954        console_printf_terminal("  packets: %8d %8d %8d %8d %8d %8d %8d %8d\n\n",
955                                statistics.txCounters[TxQid].RetryHistogram[ 8 ],
956                                statistics.txCounters[TxQid].RetryHistogram[ 9 ],
957                                statistics.txCounters[TxQid].RetryHistogram[ 10 ],
958                                statistics.txCounters[TxQid].RetryHistogram[ 11 ],
959                                statistics.txCounters[TxQid].RetryHistogram[ 12 ],
960                                statistics.txCounters[TxQid].RetryHistogram[ 13 ],
961                                statistics.txCounters[TxQid].RetryHistogram[ 14 ],
962                                statistics.txCounters[TxQid].RetryHistogram[ 15 ]);
963
964        if (statistics.txCounters[TxQid].NumPackets)
965        {
966            AverageDelay = statistics.txCounters[TxQid].SumTotalDelayMs / statistics.txCounters[TxQid].NumPackets;
967            AverageFWDelay = statistics.txCounters[TxQid].SumFWDelayUs / statistics.txCounters[TxQid].NumPackets;
968            AverageMacDelay = statistics.txCounters[TxQid].SumMacDelayUs / statistics.txCounters[TxQid].NumPackets;
969        }
970        else
971        {
972            AverageDelay = 0;
973            AverageFWDelay = 0;
974            AverageMacDelay = 0;
975        }
976
977        console_printf_terminal("  Total Delay ms (average/sum) : %d / %d\n", AverageDelay, statistics.txCounters[TxQid].SumTotalDelayMs);
978        console_printf_terminal("  FW Delay us (average/sum) : %d / %d\n", AverageFWDelay, statistics.txCounters[TxQid].SumFWDelayUs);
979        console_printf_terminal("  MAC Delay us (average/sum)   : %d / %d\n\n", AverageMacDelay, statistics.txCounters[TxQid].SumMacDelayUs);
980
981        console_printf_terminal("  Delay Ranges [msec]  : Num of packets\n");
982        console_printf_terminal("  -------------------  : --------------\n");
983        console_printf_terminal("        0   -    1     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_0_TO_1] );
984        console_printf_terminal("        1   -   10     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_1_TO_10] );
985        console_printf_terminal("       10   -   20     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_10_TO_20] );
986        console_printf_terminal("       20   -   40     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_20_TO_40] );
987        console_printf_terminal("       40   -   60     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_40_TO_60] );
988        console_printf_terminal("       60   -   80     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_60_TO_80] );
989        console_printf_terminal("       80   -  100     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_80_TO_100] );
990        console_printf_terminal("      100   -  200     : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_100_TO_200] );
991        console_printf_terminal("        Above 200      : %d\n", statistics.txCounters[TxQid].txDelayHistogram[TX_DELAY_RANGE_ABOVE_200] );
992    }
993}
994
995void cmd_show_about(ConParm_t parm[], U16 nParms)
996{
997    TIWLN_VERSION_EX data;
998
999    UNUSED(parm);
1000    UNUSED(nParms);
1001
1002    console_printf_terminal("Utility version: %s (%u.%u.%u)\n", SW_VERSION_STR, SW_RELEASE_DAY,
1003            SW_RELEASE_MONTH, SW_RELEASE_YEAR );
1004    if( TI_GetDriverVersion(g_id_adapter, &data ) )
1005        return ;
1006
1007    console_printf_terminal("Driver version: %u.%u.%u.%u.%u\n", data.DrvVersion.major, data.DrvVersion.minor,
1008            data.DrvVersion.bugfix, data.DrvVersion.subld, data.DrvVersion.build );
1009    console_printf_terminal("Firmware version: %u.%u.%u.%u.%u\n", data.FWVersion.major, data.FWVersion.minor,
1010            data.FWVersion.bugfix, data.FWVersion.subld, data.FWVersion.build );
1011    console_printf_terminal("Eeprom Version: %u.%u.%u.%u.%u\n", data.HWVersion.major, data.HWVersion.minor,
1012            data.HWVersion.bugfix, data.HWVersion.subld, data.HWVersion.build );
1013    console_printf_terminal("Eeprom Version2: %u.%u.%u.%u.%u\n", data.NVVersion.major, data.NVVersion.minor,
1014            data.NVVersion.bugfix, data.NVVersion.subld, data.HWVersion.build );
1015}
1016
1017void cmd_modify_ssid(ConParm_t parm[], U16 nParms)
1018{
1019    OS_802_11_SSID ssid = { 0 };
1020    OS_802_11_MAC_ADDRESS bssid = { 0xff,0xff,0xff,0xff,0xff,0xff };
1021    char *ssid_str;
1022
1023    if( nParms == 0 )
1024    {
1025        if(!TI_GetCurrentSSID(g_id_adapter, &ssid))
1026            ssid_str = get_ssid_string(&ssid);
1027        else
1028            ssid_str = "<error>";
1029        console_printf_terminal("SSID: %s\n",  ssid_str );
1030    }
1031    else{
1032        /* Setting the new SSID, BRCS BSSID is set to clean pre-set BSSID */
1033        TI_SetBSSID(g_id_adapter, &bssid );
1034        TI_SetSSID(g_id_adapter, (tiUINT8 *) parm[0].value);
1035}
1036}
1037
1038void cmd_modify_channel(ConParm_t parm[], U16 nParms)
1039{
1040    if( nParms == 0 )
1041    {
1042        tiUINT32 data1 = 0, data = 0;
1043        if( !TI_GetDesiredChannel( g_id_adapter, &data1) )
1044            console_printf_terminal("Channel=%d (desired: %d)\n", !TI_GetCurrentChannel(g_id_adapter, &data) ? data : -1, data1 );
1045    }
1046    else
1047        TI_SetDesiredChannel( g_id_adapter, parm[0].value );
1048}
1049
1050void cmd_set_power_mode(ConParm_t parm[], U16 nParms)
1051{
1052    OS_802_11_POWER_PROFILE mode = 0x12345678;
1053    if( nParms )
1054        TI_ConfigPowerManagement (g_id_adapter, parm[0].value );
1055    else
1056    {
1057        if( !TI_GetPowerMode(g_id_adapter, &mode ) )
1058        {
1059            console_printf_terminal("Power mode: %d\n", mode );
1060            print_available_values(power_mode_val);
1061        }
1062    }
1063}
1064
1065void cmd_set_PowerSave_PowerLevel(ConParm_t parm[], U16 nParms)
1066{
1067    OS_802_11_POWER_LEVELS mode;
1068    if( nParms )
1069        TI_SetPowerLevelPS (g_id_adapter, parm[0].value );
1070    else
1071    {
1072        if( !TI_GetPowerLevelPS(g_id_adapter, &mode ) )
1073        {
1074            console_printf_terminal("Power Level PowerSave: %d\n", mode );
1075            print_available_values(power_level_val);
1076        }
1077    }
1078}
1079
1080void cmd_set_Default_PowerLevel(ConParm_t parm[], U16 nParms)
1081{
1082    OS_802_11_POWER_LEVELS mode;
1083    if( nParms )
1084        TI_SetPowerLevelDefault (g_id_adapter, parm[0].value );
1085    else
1086    {
1087        if( !TI_GetPowerLevelDefault(g_id_adapter, &mode ) )
1088        {
1089            console_printf_terminal("Default Power Level: %d\n", mode );
1090            print_available_values(power_level_val);
1091        }
1092    }
1093}
1094
1095void cmd_set_DozeModeInAutoPowerLevel(ConParm_t parm[], U16 nParms)
1096{
1097	OS_802_11_POWER_PROFILE mode;
1098    if( nParms )
1099        TI_SetPowerLevelDozeMode (g_id_adapter, parm[0].value );
1100    else
1101    {
1102		/* set Short or Long Doze. no use of other parameters */
1103        if( !TI_GetPowerLevelDozeMode(g_id_adapter,&mode ) )
1104        {
1105            console_printf_terminal("Doze Mode in Auto Power Level: SHORT_DOZE -  %d LONG_DOZE - %d\n",
1106				OS_POWER_MODE_SHORT_DOZE,OS_POWER_MODE_LONG_DOZE);
1107        }
1108    }
1109}
1110
1111
1112void cmd_Beacon_Filter_Set_Desired_State(ConParm_t parm[], U16 nParms)
1113{
1114    /*there are two modes : feature ACTIVE & PASSIV ( or NOT ACTIVE )*/
1115    if( nParms )
1116    {
1117        TI_SetBeaconFilterDesiredState(g_id_adapter, parm[0].value );
1118    }
1119    else
1120    {
1121        console_printf_terminal("Use : 0 =  INACTIVE , 1 = ACTIVE\n" ) ;
1122
1123    }
1124}
1125
1126void cmd_Beacon_Filter_Get_Desired_State(ConParm_t parm[], U16 nParms)
1127{
1128    UINT8 desState = FALSE ;
1129
1130    TI_GetBeaconFilterDesiredState(g_id_adapter, &desState ) ;
1131    console_printf_terminal("Desired State is %s\n", (desState == FALSE)?"FILTER INACTIVE":"FILTER ACTIVE" );
1132
1133
1134}
1135
1136
1137
1138/* scan commands (new from eSTAdk 5.0) */
1139
1140void init_scan_params(void)
1141{
1142    int i,j;
1143
1144    /* init application scan default params */
1145    appScanParams.desiredSsid.len = 0;
1146    appScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE;
1147    appScanParams.band = RADIO_BAND_2_4_GHZ;
1148    appScanParams.probeReqNumber = 3;
1149    appScanParams.probeRequestRate = DRV_RATE_MASK_2_BARKER;
1150    appScanParams.numOfChannels = 11;
1151    for ( i = 0; i < 11; i++ )
1152    {
1153        for ( j = 0; j < 6; j++ )
1154        {
1155            appScanParams.channelEntry[ i ].normalChannelEntry.bssId.addr[ j ] = 0xff;
1156        }
1157        appScanParams.channelEntry[ i ].normalChannelEntry.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
1158        appScanParams.channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes = 0;
1159        appScanParams.channelEntry[ i ].normalChannelEntry.maxChannelDwellTime = 60000;
1160        appScanParams.channelEntry[ i ].normalChannelEntry.minChannelDwellTime = 30000;
1161        appScanParams.channelEntry[ i ].normalChannelEntry.txPowerDbm = MAX_TX_POWER;
1162        appScanParams.channelEntry[ i ].normalChannelEntry.channel = i + 1;
1163    }
1164
1165    /* init default scan policy */
1166    scanPolicy.normalScanInterval = 10000;
1167    scanPolicy.deterioratingScanInterval = 5000;
1168    scanPolicy.maxTrackFailures = 3;
1169    scanPolicy.BSSListSize = 4;
1170    scanPolicy.BSSNumberToStartDiscovery = 1;
1171    scanPolicy.numOfBands = 1;
1172    scanPolicy.bandScanPolicy[ 0 ].band = RADIO_BAND_2_4_GHZ;
1173    scanPolicy.bandScanPolicy[ 0 ].rxRSSIThreshold = -80;
1174    scanPolicy.bandScanPolicy[ 0 ].numOfChannles = 11;
1175    scanPolicy.bandScanPolicy[ 0 ].numOfChannlesForDiscovery = 3;
1176    for ( i = 0; i < 11; i++ )
1177    {
1178        scanPolicy.bandScanPolicy[ 0 ].channelList[ i ] = i + 1;
1179    }
1180    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
1181    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
1182    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
1183    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
1184    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.minChannelDwellTime = 15000;
1185    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_1_BARKER;
1186    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
1187    scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = MAX_TX_POWER;
1188    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
1189    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
1190    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
1191    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
1192    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.minChannelDwellTime = 15000;
1193    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_2_BARKER;
1194    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
1195    scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = MAX_TX_POWER;
1196    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
1197    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
1198    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
1199    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
1200    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.minChannelDwellTime = 15000;
1201    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_5_5_CCK;
1202    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
1203    scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = MAX_TX_POWER;
1204}
1205
1206void cmd_Scan_Start(ConParm_t parm[], U16 nParms)
1207{
1208    TI_StartScan( g_id_adapter, &appScanParams );
1209    console_printf_terminal("Application scan started.\n");
1210}
1211
1212void cmd_Scan_Stop(ConParm_t parm[], U16 nParms)
1213{
1214    TI_StopScan( g_id_adapter );
1215    console_printf_terminal("Application scan stopped.\n");
1216}
1217
1218void cmd_Scan_app_global_config(ConParm_t parm[], U16 nParms)
1219{
1220    if ( 0 == strcmp( "<empty>", (char*)parm[0].value) )
1221    {
1222        appScanParams.desiredSsid.len = 0;
1223        appScanParams.desiredSsid.ssidString[ 0 ] = '\0';
1224    }
1225    else
1226    {
1227    appScanParams.desiredSsid.len = strlen((char*)parm[0].value);
1228    memcpy( &(appScanParams.desiredSsid.ssidString), (char*)parm[0].value, appScanParams.desiredSsid.len );
1229    }
1230    appScanParams.scanType = parm[1].value;
1231    appScanParams.band = parm[2].value;
1232    appScanParams.probeReqNumber = (UINT8)parm[3].value;
1233    appScanParams.probeRequestRate = parm[4].value;
1234#ifdef TI_DBG
1235    appScanParams.Tid = (UINT8)parm[5].value;
1236    appScanParams.numOfChannels  = (UINT8)parm[6].value;
1237#else
1238    appScanParams.Tid = 0;
1239    appScanParams.numOfChannels = (UINT8)parm[5].value;
1240#endif
1241}
1242
1243void cmd_Scan_app_channel_config(ConParm_t parm[], U16 nParms)
1244{
1245    scan_normalChannelEntry_t* pChannelEntry =
1246        &(appScanParams.channelEntry[ parm[0].value ].normalChannelEntry);
1247
1248	if (parm[2].value < parm[3].value)
1249	{
1250		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
1251		return;
1252	}
1253
1254    hexStr2MACAddr( (char*)parm[1].value, &(pChannelEntry->bssId) );
1255    pChannelEntry->maxChannelDwellTime = parm[2].value;
1256    pChannelEntry->minChannelDwellTime = parm[3].value;
1257    pChannelEntry->earlyTerminationEvent = parm[4].value;
1258    pChannelEntry->ETMaxNumOfAPframes = (UINT8)parm[5].value;
1259    pChannelEntry->txPowerDbm = (UINT8)parm[6].value;
1260    pChannelEntry->channel = (UINT8)parm[7].value;
1261}
1262
1263void cmd_Scan_app_clear(ConParm_t parm[], U16 nParms)
1264{
1265    memset( &appScanParams, 0, sizeof(scan_Params_t) );
1266    console_printf_terminal("Application scan parameters cleared.\n");
1267}
1268
1269void cmd_Scan_app_display(ConParm_t parm[], U16 nParms)
1270{
1271    int i;
1272    scan_normalChannelEntry_t* pNormalChannel;
1273    char bssId[18];
1274
1275    bssId[17] = '\0';
1276    console_printf_terminal("Application Scan params:\n");
1277    console_printf_terminal("SSID: %s, Type: %s\n", appScanParams.desiredSsid.ssidString, scanType2Str[ appScanParams.scanType ].name);
1278    console_printf_terminal("Band: %s, Number of probe req:%d, probe req. rate:%s\n",
1279          band2Str[ appScanParams.band ].name, appScanParams.probeReqNumber, rate2StrFunc( appScanParams.probeRequestRate ) );
1280#ifdef TI_DBG
1281    console_printf_terminal("Tid :%d\n\n", appScanParams.Tid);
1282#else
1283    console_printf_terminal("\n");
1284#endif
1285    console_printf_terminal("Channel  BSS ID             Max time  Min time  ET event     ET frame num Power\n");
1286    console_printf_terminal("-------------------------------------------------------------------------------\n");
1287    for ( i = 0; i < appScanParams.numOfChannels; i++ )
1288    {
1289        pNormalChannel = &(appScanParams.channelEntry[ i ].normalChannelEntry);
1290        mac2HexStr( &(pNormalChannel->bssId), bssId );
1291        console_printf_terminal ("%2d       %s  %7d   %7d   %s%3d          %1d\n",
1292               pNormalChannel->channel, bssId, pNormalChannel->maxChannelDwellTime,
1293               pNormalChannel->minChannelDwellTime, EtEvent2StrFunc( pNormalChannel->earlyTerminationEvent ),
1294               pNormalChannel->ETMaxNumOfAPframes, pNormalChannel->txPowerDbm);
1295    }
1296    console_printf_terminal("\n");
1297}
1298
1299void cmd_Scan_policy_global_config(ConParm_t parm[], U16 nParms)
1300{
1301    scanPolicy.normalScanInterval =  parm[ 0 ].value;
1302    scanPolicy.deterioratingScanInterval = parm[ 1 ].value;
1303    scanPolicy.maxTrackFailures = (UINT8)(parm[ 2 ].value);
1304    scanPolicy.BSSListSize = (UINT8)(parm[ 3 ].value);
1305    scanPolicy.BSSNumberToStartDiscovery = (UINT8)(parm[ 4 ].value);
1306    scanPolicy.numOfBands = (UINT8)(parm[ 5 ].value);
1307}
1308
1309void cmd_Scan_band_global_config(ConParm_t parm[], U16 nParms)
1310{
1311    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
1312
1313    bandPolicy->band = parm[ 1 ].value;
1314    bandPolicy->rxRSSIThreshold = (S8)(parm[ 2 ].value);
1315    bandPolicy->numOfChannlesForDiscovery = (UINT8)(parm[ 3 ].value);
1316    bandPolicy->numOfChannles = (UINT8)(parm[ 4 ].value);
1317}
1318
1319void cmd_Scan_band_channel_config(ConParm_t parm[], U16 nParms)
1320{
1321    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
1322
1323    bandPolicy->channelList[ parm[ 1 ].value ] = (UINT8)(parm[ 2 ].value);
1324}
1325
1326void cmd_Scan_band_track_config(ConParm_t parm[], U16 nParms)
1327{
1328    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
1329
1330	if (parm[6].value < parm[7].value)
1331	{
1332		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
1333		return;
1334	}
1335
1336    bandPolicy->trackingMethod.scanType = parm[ 1 ].value;
1337
1338    switch (bandPolicy->trackingMethod.scanType)
1339    {
1340    case SCAN_TYPE_NORMAL_ACTIVE:
1341    case SCAN_TYPE_NORMAL_PASSIVE:
1342        bandPolicy->trackingMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
1343        bandPolicy->trackingMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
1344        bandPolicy->trackingMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1345        bandPolicy->trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1346        bandPolicy->trackingMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
1347        bandPolicy->trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
1348        bandPolicy->trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
1349        break;
1350
1351    case SCAN_TYPE_TRIGGERED_ACTIVE:
1352    case SCAN_TYPE_TRIGGERED_PASSIVE:
1353
1354		/* Check if valid TID */
1355		if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255))
1356		{
1357			console_printf_terminal ("ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
1358			parm[ 4 ].value = 255;
1359		}
1360        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.triggeringTid = (UINT8)(parm[ 4 ].value);
1361        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
1362        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
1363        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1364        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1365        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
1366        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
1367        bandPolicy->trackingMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
1368        break;
1369
1370    case SCAN_TYPE_SPS:
1371        bandPolicy->trackingMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1372        bandPolicy->trackingMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1373        bandPolicy->trackingMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
1374        break;
1375
1376    default:
1377        bandPolicy->trackingMethod.scanType = SCAN_TYPE_NO_SCAN;
1378        break;
1379    }
1380}
1381
1382void cmd_Scan_band_discover_config(ConParm_t parm[], U16 nParms)
1383{
1384    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
1385
1386	if (parm[6].value < parm[7].value)
1387	{
1388		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
1389		return;
1390	}
1391
1392    bandPolicy->discoveryMethod.scanType = parm[ 1 ].value;
1393
1394    switch (bandPolicy->discoveryMethod.scanType)
1395    {
1396    case SCAN_TYPE_NORMAL_ACTIVE:
1397    case SCAN_TYPE_NORMAL_PASSIVE:
1398        bandPolicy->discoveryMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
1399        bandPolicy->discoveryMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
1400        bandPolicy->discoveryMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1401        bandPolicy->discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1402        bandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
1403        bandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
1404        bandPolicy->discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
1405        break;
1406
1407    case SCAN_TYPE_TRIGGERED_ACTIVE:
1408    case SCAN_TYPE_TRIGGERED_PASSIVE:
1409		/* Check if valid TID */
1410		if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255))
1411		{
1412			console_printf_terminal ("ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
1413			parm[ 4 ].value = 255;
1414		}
1415        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.triggeringTid = (UINT8)(parm[ 4 ].value);
1416        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
1417        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
1418        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1419        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1420        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
1421        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
1422        bandPolicy->discoveryMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
1423        break;
1424
1425    case SCAN_TYPE_SPS:
1426        bandPolicy->discoveryMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1427        bandPolicy->discoveryMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1428        bandPolicy->discoveryMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
1429        break;
1430
1431    default:
1432        bandPolicy->discoveryMethod.scanType = SCAN_TYPE_NO_SCAN;
1433        break;
1434    }
1435}
1436
1437void cmd_Scan_band_immed_config(ConParm_t parm[], U16 nParms)
1438{
1439    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ parm [ 0 ].value ]);
1440
1441	if (parm[6].value < parm[7].value)
1442	{
1443		console_printf_terminal ("Max Dwell Time must be larger than or equal to Min Dwell Time...\n");
1444		return;
1445	}
1446
1447    bandPolicy->immediateScanMethod.scanType = parm[ 1 ].value;
1448
1449    switch (bandPolicy->immediateScanMethod.scanType)
1450    {
1451    case SCAN_TYPE_NORMAL_ACTIVE:
1452    case SCAN_TYPE_NORMAL_PASSIVE:
1453        bandPolicy->immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
1454        bandPolicy->immediateScanMethod.method.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
1455        bandPolicy->immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1456        bandPolicy->immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1457        bandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
1458        bandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
1459        bandPolicy->immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
1460        break;
1461
1462    case SCAN_TYPE_TRIGGERED_ACTIVE:
1463    case SCAN_TYPE_TRIGGERED_PASSIVE:
1464		/* Check if valid TID */
1465		if (((parm[ 4 ].value) > 7) && ((parm[ 4 ].value) != 255))
1466		{
1467			console_printf_terminal ("ERROR Tid (AC) should be 0..7 or 255 instead = %d (using default = 255)\n",(parm[ 4 ].value));
1468			parm[ 4 ].value = 255;
1469		}
1470        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.triggeringTid = (UINT8)(parm[ 4 ].value);
1471        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.maxChannelDwellTime = (parm[ 6 ].value);
1472        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.minChannelDwellTime = (parm[ 7 ].value);
1473        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1474        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1475        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.bitrate = parm[ 9 ].value;
1476        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.numOfProbeReqs = (UINT8)(parm[ 8 ].value);
1477        bandPolicy->immediateScanMethod.method.TidTriggerdMethodParams.basicMethodParams.probReqParams.txPowerDbm = (UINT8)(parm[ 10 ].value);
1478        break;
1479
1480    case SCAN_TYPE_SPS:
1481        bandPolicy->immediateScanMethod.method.spsMethodParams.earlyTerminationEvent = parm[ 2 ].value;
1482        bandPolicy->immediateScanMethod.method.spsMethodParams.ETMaxNumberOfApFrames = (UINT8)(parm[ 3 ].value);
1483        bandPolicy->immediateScanMethod.method.spsMethodParams.scanDuration = parm[ 5 ].value;
1484        break;
1485
1486    default:
1487        bandPolicy->immediateScanMethod.scanType = SCAN_TYPE_NO_SCAN;
1488        break;
1489    }
1490}
1491
1492void cmd_Scan_policy_display(ConParm_t parm[], U16 nParms)
1493{
1494    int i;
1495
1496    console_printf_terminal("Scan Policy:\n");
1497    console_printf_terminal("Normal scan interval: %d, deteriorating scan interval: %d\n",
1498          scanPolicy.normalScanInterval, scanPolicy.deterioratingScanInterval);
1499    console_printf_terminal("Max track attempt failures: %d\n", scanPolicy.maxTrackFailures);
1500    console_printf_terminal("BSS list size: %d, number of BSSes to start discovery: %d\n",
1501          scanPolicy.BSSListSize, scanPolicy.BSSNumberToStartDiscovery);
1502    console_printf_terminal("Number of configured bands: %d\n", scanPolicy.numOfBands);
1503    for ( i = 0; i < scanPolicy.numOfBands; i++ )
1504    {
1505        cmd_Scan_print_band( i );
1506    }
1507}
1508
1509void cmd_Scan_print_band( int i )
1510{
1511    scan_bandPolicy_t* bandPolicy = &(scanPolicy.bandScanPolicy[ i ]);
1512    int j;
1513
1514    console_printf_terminal("\nBand: %s\n", band2Str[ bandPolicy->band ].name);
1515    console_printf_terminal("RSSI Threshold: %d dBm\n", bandPolicy->rxRSSIThreshold);
1516    console_printf_terminal("Number of channels for each discovery interval: %d\n", bandPolicy->numOfChannlesForDiscovery);
1517    console_printf_terminal("\nTracking Method:\n");
1518    cmd_Scan_print_method( &(bandPolicy->trackingMethod) );
1519    console_printf_terminal("\nDiscovery Method:\n");
1520    cmd_Scan_print_method( &(bandPolicy->discoveryMethod) );
1521    console_printf_terminal("\nImmediate Scan Method:\n");
1522    cmd_Scan_print_method( &(bandPolicy->immediateScanMethod) );
1523    if ( bandPolicy->numOfChannles > 0 )
1524    {
1525        console_printf_terminal("\nChannel list: ");
1526        for ( j = 0; j < bandPolicy->numOfChannles; j++ )
1527        {
1528            console_printf_terminal("%3d ", bandPolicy->channelList[ j ]);
1529        }
1530        console_printf_terminal("\n");
1531    }
1532    else
1533        console_printf_terminal("\nNo channels defined.\n");
1534}
1535
1536void cmd_Scan_print_method( scan_Method_t* scanMethod )
1537{
1538    console_printf_terminal("Scan type: %s\n", scanType2Str[ scanMethod->scanType ].name);
1539    switch (scanMethod->scanType)
1540    {
1541    case SCAN_TYPE_NORMAL_ACTIVE:
1542    case SCAN_TYPE_NORMAL_PASSIVE:
1543        cmd_Scan_print_basic_method( &(scanMethod->method.basicMethodParams) );
1544        break;
1545
1546    case SCAN_TYPE_TRIGGERED_ACTIVE:
1547    case SCAN_TYPE_TRIGGERED_PASSIVE:
1548        cmd_Scan_print_triggered_method( &(scanMethod->method.TidTriggerdMethodParams) );
1549        break;
1550
1551    case SCAN_TYPE_SPS:
1552        cmd_Scan_print_sps_method( &(scanMethod->method.spsMethodParams) );
1553        break;
1554
1555    case SCAN_TYPE_NO_SCAN:
1556        break;
1557    }
1558}
1559
1560void cmd_Scan_print_basic_method( scan_basicMethodParams_t* basicMethodParams )
1561{
1562    console_printf_terminal("Max channel dwell time: %d, Min channel dwell time: %d\n",
1563          basicMethodParams->maxChannelDwellTime, basicMethodParams->minChannelDwellTime);
1564    console_printf_terminal("ET condition: %s, ET number of frames: %d\n",
1565          EtEvent2StrFunc( basicMethodParams->earlyTerminationEvent ), basicMethodParams->ETMaxNumberOfApFrames);
1566    console_printf_terminal("Probe request number: %d, probe request rate: %s, TX power (Dbm/10): %d\n",
1567          basicMethodParams->probReqParams.numOfProbeReqs, rate2StrFunc( basicMethodParams->probReqParams.bitrate ),
1568          basicMethodParams->probReqParams.txPowerDbm);
1569}
1570
1571void cmd_Scan_print_triggered_method( scan_TidTriggeredMethodParams_t* triggeredMethodParams )
1572{
1573    console_printf_terminal("Triggering Tid: %d\n", triggeredMethodParams->triggeringTid);
1574    cmd_Scan_print_basic_method( &(triggeredMethodParams->basicMethodParams) );
1575}
1576
1577void cmd_Scan_print_sps_method( scan_SPSMethodParams_t* spsMethodParams )
1578{
1579    console_printf_terminal("ET condition: %s, ET number of frames: %d\n",
1580          EtEvent2StrFunc( spsMethodParams->earlyTerminationEvent ), spsMethodParams->ETMaxNumberOfApFrames);
1581    console_printf_terminal("Scan duration: %d\n", spsMethodParams->scanDuration);
1582}
1583
1584void cmd_Scan_policy_clear(ConParm_t parm[], U16 nParms)
1585{
1586    memset( &scanPolicy, 0, sizeof(scan_Policy_t) );
1587    console_printf_terminal("Scan policy cleared.\n");
1588}
1589
1590void cmd_Scan_policy_store(ConParm_t parm[], U16 nParms)
1591{
1592    TI_SetScanPolicy( g_id_adapter, (UINT8*)&scanPolicy, sizeof(scan_Policy_t) );
1593    console_printf_terminal("Scan policy stored.\n");
1594}
1595
1596void cmd_Scan_get_bss_list(ConParm_t parm[], U16 nParms)
1597{
1598    bssList_t list;
1599    int i;
1600
1601    /* get list */
1602    if ( (TI_RESULT_OK != TI_GetScanBssList( g_id_adapter, &list )) || (0 == list.numOfEntries) )
1603    {
1604        return;
1605    }
1606
1607    /* console_printf_terminal list */
1608    console_printf_terminal("BSS List:\n");
1609    console_printf_terminal("%-17s  %-7s  %-6s  %-4s  %-10s\n", "BSSID", "Band", "Channel", "RSSI", "Neighbor?");
1610    console_printf_terminal("-----------------------------------------------------\n");
1611    for  ( i = 0; i < list.numOfEntries; i++ )
1612    {
1613
1614        console_printf_terminal( "%s  %s  %-7d  %-4d  %s\n",
1615               print_mac_2_str(list.BSSList[ i ].BSSID.addr), band2Str[ list.BSSList[ i ].band ].name,
1616               list.BSSList[ i ].channel, list.BSSList[ i ].RSSI,
1617               (TRUE == list.BSSList[ i ].bNeighborAP ? "Yes" : "No") );
1618    }
1619}
1620
1621void cmd_set_dtag_to_ac_mapping_table(ConParm_t parm[], U16 nParms)
1622{
1623    int				i;
1624    acTrfcType_e	dtagToAcTable[MAX_NUM_OF_802_1d_TAGS];
1625
1626    for (i=0; i<MAX_NUM_OF_802_1d_TAGS; i++)
1627    {
1628        dtagToAcTable[i] = (UINT32) parm[i].value;
1629	}
1630	console_printf_terminal("Input parameters =%d, %d, %d, %d, %d, %d, %d, %d\n",
1631                    (UINT32) parm[0].value,
1632                    (UINT32) parm[1].value,
1633                    (UINT32) parm[2].value,
1634                    (UINT32) parm[3].value,
1635                    (UINT32) parm[4].value,
1636                    (UINT32) parm[5].value,
1637                    (UINT32) parm[6].value,
1638                    (UINT32) parm[7].value);
1639
1640	if (TI_SetDTagToAcMappingTable(g_id_adapter, dtagToAcTable) == TI_RESULT_OK)
1641	{
1642	}
1643	else
1644	{
1645		console_printf_terminal ("Error: could not set tag_ToAcClsfrTable ...\n");
1646	}
1647}
1648
1649void cmd_set_vad(ConParm_t parm[], U16 nParms)
1650{
1651	txDataVadTimerParams_t  pVadTimer;
1652
1653	if (0 == nParms)	// GET operation
1654	{
1655		console_printf_terminal("Set VAD: \n");
1656		console_printf_terminal("    Parm 0 -- 1: ENABLE; 0: DISABLE\n");
1657		console_printf_terminal("    Parm 1 -- VAD timer duration in ms for enabling action\n");
1658		if (TI_GetVAD(g_id_adapter, &pVadTimer) == TI_RESULT_OK)
1659		{
1660
1661		    console_printf_terminal("Current param values: %d, %d\n",
1662				 pVadTimer.vadTimerEnabled, pVadTimer.vadTimerDuration);
1663		}
1664	}
1665	else
1666	{
1667		pVadTimer.vadTimerEnabled  = (UINT16) parm[0].value;
1668		pVadTimer.vadTimerDuration = (UINT16) parm[1].value;
1669
1670		if (pVadTimer.vadTimerEnabled)
1671		{
1672			console_printf_terminal("Enabling VAD timer (cycle = %d ms)\n", pVadTimer.vadTimerDuration);
1673		}
1674		else
1675		{
1676			console_printf_terminal("Disabling VAD timer\n");
1677		}
1678
1679		if (TI_SetVAD(g_id_adapter, &pVadTimer) == TI_RESULT_OK)
1680		{
1681			console_printf_terminal("Setting VAD is done\n");
1682		}
1683	}
1684}
1685
1686
1687void cmd_set_qos_params(ConParm_t parm[], U16 nParms)
1688{
1689   OS_802_11_QOS_PARAMS pQosParams;
1690
1691   pQosParams.acID=parm[0].value;
1692   pQosParams.MaxLifeTime=parm[1].value;
1693   pQosParams.VoiceDeliveryProtocol=0;
1694   pQosParams.PSDeliveryProtocol=0;
1695
1696   if (nParms == 7) /* If the user has input 7 parameters, it means he gave Voice+PS delivery protocol values */
1697   {
1698      pQosParams.VoiceDeliveryProtocol=parm[5].value;
1699      pQosParams.PSDeliveryProtocol=parm[6].value;
1700
1701      /* If this QOS config was done for a queue OTHER THAN VO, we will zero the DeliveryProtocolPsPoll parameter and notify the user */
1702      if ((parm[0].value != 3) && (parm[5].value != 0))
1703         {
1704            pQosParams.VoiceDeliveryProtocol = 0;
1705            console_printf_terminal("Since the acID is not VO, resetting VoiceDeliveryProtocol parameter to PS_NONE\n");
1706         }
1707      if ((pQosParams.VoiceDeliveryProtocol == 1) && (pQosParams.PSDeliveryProtocol == 1))
1708      {
1709            pQosParams.VoiceDeliveryProtocol = 1;
1710            pQosParams.PSDeliveryProtocol = 0;
1711            console_printf_terminal("Since the VoiceDeliveryProtocol is PS_POLL, resetting PSDeliveryProtocol to Legacy\n");
1712      }
1713   }
1714
1715   if (TI_SetQosParameters(g_id_adapter, &pQosParams) == TI_RESULT_OK)
1716   {
1717      console_printf_terminal("Sent QOS params to driver...\n AC Number=%d \n MaxLifeTime=%d \n DeliveryProtocolPsPoll = %d\n PSDeliveryProtocol = %d\n",
1718          pQosParams.acID,
1719          pQosParams.MaxLifeTime,
1720          pQosParams.VoiceDeliveryProtocol,
1721          pQosParams.PSDeliveryProtocol);
1722   }
1723   else
1724   {
1725      console_printf_terminal ("Error: could not set QOS params...\n");
1726   }
1727}
1728
1729void cmd_set_rxTimeOut_params(ConParm_t parm[], U16 nParms)
1730{
1731    OS_802_11_QOS_RX_TIMEOUT_PARAMS rxTimeOut;
1732
1733    rxTimeOut.psPoll = parm[0].value;
1734    rxTimeOut.UPSD   = parm[1].value;
1735
1736    if (nParms != 2)
1737    {
1738        console_printf_terminal("Please enter Rx Time Out:\n");
1739        console_printf_terminal("Param 0 - psPoll (0 - 65000)\n");
1740        console_printf_terminal("Param 1 - UPSD (1 - 65000)\n");
1741    }
1742    else
1743    {
1744       if (TI_SetQosRxTimeOut(g_id_adapter, &rxTimeOut) == TI_RESULT_OK)
1745       {
1746          console_printf_terminal("Sent QOS Rx TimeOut params to driver...\n PsPoll = %d\n UPSD = %d\n",
1747              rxTimeOut.psPoll,
1748              rxTimeOut.UPSD);
1749       }
1750       else
1751       {
1752          console_printf_terminal ("Error: could not set Rx TimeOut..\n");
1753       }
1754    }
1755}
1756
1757
1758void cmd_enable_rx_data_filters(ConParm_t parm[], U16 nParms)
1759{
1760    console_printf_terminal("Enabling Rx data filtering...\n");
1761    TI_EnableDisableRxDataFilters( g_id_adapter, TRUE );
1762}
1763
1764
1765void cmd_disable_rx_data_filters(ConParm_t parm[], U16 nParms)
1766{
1767    console_printf_terminal("Disabling Rx data filtering...\n");
1768    TI_EnableDisableRxDataFilters( g_id_adapter, FALSE );
1769}
1770
1771
1772void cmd_get_rx_data_filters_statistics(ConParm_t parm[], U16 nParms)
1773{
1774    TIWLAN_DATA_FILTER_STATISTICS statistics;
1775
1776
1777    console_printf_terminal("Rx data filtering statistics:\n");
1778
1779    TI_GetRxDataFiltersStatistics( g_id_adapter, &statistics );
1780
1781    console_printf_terminal("Unmatched packets: %u\n", statistics.UnmatchedPacketsCount);
1782    console_printf_terminal("Packets matching filter #1: %u\n", statistics.MatchedPacketsCount[0]);
1783    console_printf_terminal("Packets matching filter #2: %u\n", statistics.MatchedPacketsCount[1]);
1784    console_printf_terminal("Packets matching filter #3: %u\n", statistics.MatchedPacketsCount[2]);
1785    console_printf_terminal("Packets matching filter #4: %u\n", statistics.MatchedPacketsCount[3]);
1786}
1787
1788void cmd_show_power_consumption_stats(ConParm_t parm[])
1789{
1790    PowerConsumptionTimeStat_t statistics;
1791
1792
1793    TI_GetPowerConsumptionStatistics( g_id_adapter, &statistics );
1794
1795    console_printf_terminal("\nPower Consumption Statistics:\n");
1796    console_printf_terminal("-----------------------------\n");
1797    console_printf_terminal("activeTimeCnt_H: %u\n", statistics.activeTimeCnt_Hi);
1798    console_printf_terminal("activeTimeCnt_Low: %u\n", statistics.activeTimeCnt_Low);
1799    console_printf_terminal("elpTimeCnt_Hi: %u\n", statistics.elpTimeCnt_Hi);
1800    console_printf_terminal("elpTimeCnt_Low: %u\n", statistics.elpTimeCnt_Low);
1801    console_printf_terminal("powerDownTimeCnt_Hi: %u\n", statistics.powerDownTimeCnt_Hi);
1802    console_printf_terminal("powerDownTimeCnt_Low: %u\n", statistics.powerDownTimeCnt_Low);
1803
1804}
1805
1806
1807
1808static void parse_hex_string(char * pString, tiUINT8 * pBuffer, tiUINT8 * Length)
1809{
1810    char ch;
1811    int iter = 0;
1812
1813    while ((ch = pString[iter]))
1814    {
1815        UINT8 val = ((ch >= '0' && ch <= '9') ? (ch - '0') :
1816                     (ch >= 'A' && ch <= 'F') ? (0xA + ch - 'A') :
1817                     (ch >= 'a' && ch <= 'f') ? (0xA + ch - 'a') : 0);
1818
1819        /* even indexes go to the lower nibble, odd indexes push them to the */
1820        /* higher nibble and then go themselves to the lower nibble. */
1821        if (iter % 2)
1822            pBuffer[iter / 2] = ((pBuffer[iter / 2] << (BIT_TO_BYTE_FACTOR / 2)) | val);
1823        else
1824            pBuffer[iter / 2] = val;
1825
1826        ++iter;
1827    }
1828
1829    /* iter = 0 len = 0, iter = 1 len = 1, iter = 2 len = 1, and so on... */
1830    *Length = (iter + 1) / 2;
1831}
1832
1833static void parse_binary_string(char * pString, tiUINT8 * pBuffer, tiUINT8 * Length)
1834{
1835    char ch;
1836    int iter = 0;
1837
1838    while ((ch = pString[iter]))
1839    {
1840        UINT8 val = (ch == '1' ? 1 : 0);
1841
1842        if (iter % BIT_TO_BYTE_FACTOR)
1843            pBuffer[iter / BIT_TO_BYTE_FACTOR] |= (val << (iter % BIT_TO_BYTE_FACTOR));
1844        else
1845            pBuffer[iter / BIT_TO_BYTE_FACTOR] = val;
1846
1847        ++iter;
1848    }
1849
1850    /* iter = 0 len = 0, iter = 1 len = 1, iter = 8 len = 1, and so on... */
1851    *Length = (iter + BIT_TO_BYTE_FACTOR - 1) / BIT_TO_BYTE_FACTOR;
1852}
1853
1854void cmd_add_rx_data_filter(ConParm_t parm[], U16 nParms)
1855{
1856    tiUINT32 resultCode;
1857    TIWLAN_DATA_FILTER_REQUEST request;
1858
1859    char * mask = (char *) parm[1].value;
1860    char * pattern = (char *) parm[2].value;
1861
1862
1863    request.Offset = (UINT8) parm[0].value;
1864
1865    parse_binary_string(mask, request.Mask, &request.MaskLength);
1866    parse_hex_string(pattern, request.Pattern, &request.PatternLength);
1867
1868    resultCode = TI_AddRxDataFilter(g_id_adapter, &request);
1869
1870
1871    console_printf_terminal(resultCode == RX_NO_AVAILABLE_FILTERS ? "Error: There are no available filter slots.\n" :
1872                            resultCode == RX_FILTER_ALREADY_EXISTS ? "Error: Filter already exists.\n" :
1873                            resultCode == NOK ? "Error: Could not add the filter.\n" :
1874                            "Filter added.\n");
1875}
1876
1877void cmd_remove_rx_data_filter(ConParm_t parm[], U16 nParms)
1878{
1879    tiUINT32 resultCode;
1880    TIWLAN_DATA_FILTER_REQUEST request;
1881
1882    char * mask = (char *) parm[1].value;
1883    char * pattern = (char *) parm[2].value;
1884
1885    request.Offset = (UINT8) parm[0].value;
1886
1887    parse_binary_string(mask, request.Mask, &request.MaskLength);
1888    parse_hex_string(pattern, request.Pattern, &request.PatternLength);
1889
1890    resultCode = TI_RemoveRxDataFilter(g_id_adapter, &request);
1891
1892    console_printf_terminal(resultCode == RX_FILTER_DOES_NOT_EXIST ? "Error: Filter was not found.\n" :
1893                            resultCode == NOK ? "Error: Could not remove the filter, removal request must be identical to add request.\n" :
1894                            "Filter removed.\n");
1895}
1896
1897void cmd_MaxRxLifetime_params(ConParm_t parm[], U16 nParms)
1898{
1899    PLT_MIB_t Mib;
1900    UINT32 Status;
1901    memset(&Mib, 0, sizeof(Mib));
1902    Mib.aMib = PLT_MIB_dot11MaxReceiveLifetime;
1903
1904	if (nParms != 1)
1905	{
1906	   console_printf_terminal("Max Rx lifetime: [0 - 4294967295(0xFFFFFFFF)]\n");
1907
1908	}
1909
1910	if (nParms == 0) /*Get MaxRxlifetime */
1911    {
1912        Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
1913        if (OK == Status)
1914  	       console_printf_terminal("MaxRxLifetime = %d\n", Mib.aData.MaxReceiveLifeTime);
1915    }
1916    else if (nParms == 1)
1917    {
1918        Mib.Length = sizeof(Mib.aData.MaxReceiveLifeTime);
1919        Mib.aData.MaxReceiveLifeTime = parm[0].value;
1920        if (OK != TI_PLT_WriteMIB(g_id_adapter, &Mib))
1921            console_printf_terminal("TI_PLT_WriteMIB failed\n");
1922    }
1923}
1924
1925
1926void cmd_add_tspec(ConParm_t parm[], U16 nParms)
1927{
1928   OS_802_11_QOS_TSPEC_PARAMS pTspecParams;
1929   tiUINT32 resultCode;
1930
1931   pTspecParams.uUserPriority = parm[0].value;
1932   pTspecParams.uNominalMSDUsize = parm[1].value;
1933   pTspecParams.uMeanDataRate = parm[2].value;
1934   pTspecParams.uMinimumPHYRate = parm[3].value * 1000 * 1000;
1935   pTspecParams.uSurplusBandwidthAllowance = parm[4].value << 13;
1936   pTspecParams.uAPSDFlag = parm[5].value;
1937
1938   resultCode = TI_AddTspec (g_id_adapter,&pTspecParams);
1939
1940   switch (resultCode)
1941   {
1942   case OK:
1943      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",
1944               parm[0].value,
1945               parm[1].value,
1946               parm[2].value,
1947               parm[3].value,
1948               parm[4].value,
1949               parm[5].value);
1950      break;
1951   case TRAFIC_ADM_PENDING:
1952      console_printf_terminal ("Driver is still waiting for a response of previous request...\n");
1953      break;
1954   case AC_ALREADY_IN_USE:
1955      console_printf_terminal ("Other user priority from the same AC has already used a TSPEC...\n");
1956      break;
1957   case NOT_CONNECTED:
1958      console_printf_terminal ("Not connected to an AP...\n");
1959      break;
1960   case NO_QOS_AP:
1961      console_printf_terminal ("AP does not support QOS...\n");
1962      break;
1963   case NOK:
1964      console_printf_terminal ("Invalid parameter...\n");
1965      break;
1966   default:
1967      console_printf_terminal ("Unknown return value...\n");
1968      break;
1969   }
1970
1971   return;
1972}
1973
1974void cmd_get_tspec_params(ConParm_t parm[], U16 nParms)
1975{
1976   OS_802_11_QOS_TSPEC_PARAMS pTspecParams;
1977   tiUINT32 resultCode;
1978
1979   pTspecParams.uUserPriority = parm[0].value;
1980
1981   resultCode = TI_GetTspecParameters(g_id_adapter, &pTspecParams);
1982
1983   switch (resultCode)
1984   {
1985   case OK:
1986      console_printf_terminal ("TSpec parameters retrieved:\nuUserPriority = %d\nuNominalMSDUsize = %d\nuMeanDataRate = %d\nuMinimumPHYRate = %d\nuSurplusBandwidthAllowance = %d\nuUAPSD_Flag = %d\nuMediumTime = %d\n",
1987               pTspecParams.uUserPriority,
1988               pTspecParams.uNominalMSDUsize,
1989               pTspecParams.uMeanDataRate,
1990               pTspecParams.uMinimumPHYRate,
1991               pTspecParams.uSurplusBandwidthAllowance,
1992               pTspecParams.uAPSDFlag,
1993               pTspecParams.uMediumTime);
1994      break;
1995   case USER_PRIORITY_NOT_ADMITTED:
1996      console_printf_terminal ("User Priority is not admitted...\n");
1997      break;
1998   case NOT_CONNECTED:
1999      console_printf_terminal ("Not connected to an AP...\n");
2000      break;
2001   case NO_QOS_AP:
2002      console_printf_terminal ("AP does not support QOS...\n");
2003      break;
2004   case NOK:
2005      console_printf_terminal ("Invalid parameter...\n");
2006      break;
2007   default:
2008      console_printf_terminal ("Unknown return value...\n");
2009      break;
2010   }
2011
2012   return;
2013}
2014
2015void cmd_delete_tspec(ConParm_t parm[], U16 nParms)
2016{
2017   OS_802_11_QOS_DELETE_TSPEC_PARAMS pDelTspecParams;
2018   tiUINT32 resultCode;
2019
2020   pDelTspecParams.uUserPriority = parm[0].value;
2021   pDelTspecParams.uReasonCode = parm[1].value;
2022
2023   resultCode = TI_DeleteTspec(g_id_adapter, &pDelTspecParams);
2024
2025   switch (resultCode)
2026   {
2027   case OK:
2028      console_printf_terminal ("TSPEC Delete request sent to driver...\n uUserPriority = %d\n uReasonCode = %d\n",
2029               pDelTspecParams.uUserPriority,
2030               pDelTspecParams.uReasonCode);
2031      break;
2032   case NOT_CONNECTED:
2033      console_printf_terminal ("Not connected to an AP...\n");
2034      break;
2035   case NO_QOS_AP:
2036      console_printf_terminal ("AP does not support QOS...\n");
2037      break;
2038   case NOK:
2039      console_printf_terminal ("Invalid parameter...\n");
2040      break;
2041   default:
2042      console_printf_terminal ("Unknown return value...\n");
2043      break;
2044   }
2045
2046}
2047
2048void cmd_get_ap_qos_params(ConParm_t parm[], U16 nParms)
2049{
2050   OS_802_11_AC_QOS_PARAMS pACQosParams;
2051   int i = 0;
2052   tiUINT32 resultCode;
2053
2054   pACQosParams.uAC = i;
2055   /* Read AC 0 parameters - just to check if connected to QOS AP etc */
2056   resultCode = TI_GetAPQosParameters(g_id_adapter, &pACQosParams);
2057
2058   switch (resultCode)
2059   {
2060   case OK:
2061   console_printf_terminal ("AP QOS Parameters:\n");
2062         console_printf_terminal ("+----+-------------+----------+-----------+-----------+-----------+\n");
2063         console_printf_terminal ("| AC | AdmCtrlFlag |   AIFS   |   CwMin   |   CwMax   | TXOPLimit |\n");
2064         console_printf_terminal ("+----+-------------+----------+-----------+-----------+-----------+\n");
2065
2066
2067   for (i=0; i<4; i++)
2068      {
2069         pACQosParams.uAC = i;
2070         resultCode = TI_GetAPQosParameters(g_id_adapter, &pACQosParams);
2071
2072               console_printf_terminal ("| %2d | %11d | %8d | %9d | %9d | %9d |\n",i,
2073               pACQosParams.uAssocAdmissionCtrlFlag,
2074               pACQosParams.uAIFS,
2075               pACQosParams.uCwMin,
2076               pACQosParams.uCwMax,
2077               pACQosParams.uTXOPLimit);
2078      }
2079
2080         console_printf_terminal ("+----+-------------+----------+-----------+-----------+-----------+\n");
2081      break;
2082   case NOT_CONNECTED:
2083      console_printf_terminal ("Not connected to an AP...\n");
2084      break;
2085   case NO_QOS_AP:
2086      console_printf_terminal ("AP does not support QOS...\n");
2087      break;
2088   case NOK:
2089      console_printf_terminal ("Invalid parameter...\n");
2090      break;
2091   default:
2092      console_printf_terminal ("Unknown return value...\n");
2093      break;
2094   }
2095
2096}
2097
2098void cmd_get_ap_qos_capabilities(ConParm_t parm[], U16 nParms)
2099{
2100   OS_802_11_AP_QOS_CAPABILITIES_PARAMS pAPQosCapabiltiesParams;
2101   tiUINT32 resultCode;
2102
2103   resultCode = TI_GetAPQosCapabilitesParameters(g_id_adapter, &pAPQosCapabiltiesParams);
2104
2105   switch (resultCode)
2106   {
2107   case TI_RESULT_OK:
2108      console_printf_terminal ("AP Qos Capabilities:\n QOSFlag = %d\n APSDFlag = %d\n",pAPQosCapabiltiesParams.uQOSFlag,pAPQosCapabiltiesParams.uAPSDFlag);
2109      break;
2110   case NOT_CONNECTED:
2111      console_printf_terminal ("Not connected to an AP...\n");
2112      break;
2113   case NO_QOS_AP:
2114      console_printf_terminal ("AP does not support QOS...\n");
2115      break;
2116   default:
2117      console_printf_terminal ("Unknown return value...\n");
2118      break;
2119   }
2120
2121   return;
2122}
2123
2124void cmd_get_ac_status(ConParm_t parm[], U16 nParms)
2125{
2126   OS_802_11_AC_UPSD_STATUS_PARAMS pAcStatusParams;
2127   tiUINT32 resultCode;
2128
2129   pAcStatusParams.uAC = parm[0].value;
2130
2131   resultCode = TI_GetCurrentACStatus(g_id_adapter, &pAcStatusParams);
2132
2133   switch (resultCode)
2134   {
2135   case TI_RESULT_OK:
2136      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",
2137               pAcStatusParams.uAC,
2138               pAcStatusParams.uCurrentUAPSDStatus,
2139               pAcStatusParams.pCurrentAdmissionStatus);
2140      break;
2141   case NOT_CONNECTED:
2142      console_printf_terminal ("Not connected to an AP...\n");
2143      break;
2144   case NO_QOS_AP:
2145      console_printf_terminal ("AP does not support QOS...\n");
2146      break;
2147   case NOK:
2148      console_printf_terminal ("Invalid parameters...\n");
2149      break;
2150   default:
2151      console_printf_terminal ("Unknown return value...\n");
2152      break;
2153   }
2154
2155}
2156
2157void cmd_get_desired_ps_mode(ConParm_t parm[], U16 nParms)
2158{
2159   OS_802_11_QOS_DESIRED_PS_MODE pDesiredPsMode;
2160   tiUINT32 resultCode;
2161
2162   resultCode = TI_GetDesiredPsMode(g_id_adapter, &pDesiredPsMode);
2163
2164   switch (resultCode)
2165   {
2166   case TI_RESULT_OK:
2167      console_printf_terminal ("\n\
2168Desired PS Mode (0=PS_POLL, 1=UPSD, 2=PS_NONE):\n\
2169===============================================\n\
2170General Desired Ps Mode  =  %d\n\
2171 BE_AC  Desired Ps Mode  =  %d\n\
2172 BK_AC  Desired Ps Mode  =  %d\n\
2173 VI_AC  Desired Ps Mode  =  %d\n\
2174 VO_AC  Desired Ps Mode  =  %d\n",
2175              pDesiredPsMode.uDesiredPsMode,
2176              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BE],
2177              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_BK],
2178              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VI],
2179              pDesiredPsMode.uDesiredWmeAcPsMode[QOS_AC_VO]);
2180
2181      break;
2182   case NOK:
2183      console_printf_terminal ("Invalid parameters...\n");
2184      break;
2185   default:
2186      console_printf_terminal ("Unknown return value...\n");
2187      break;
2188   }
2189}
2190
2191
2192
2193void cmd_medium_usage_threshold(ConParm_t parm[], U16 nParms)
2194{
2195   OS_802_11_THRESHOLD_CROSS_PARAMS pThresholdCrossParams;
2196   tiUINT32 resultCode;
2197
2198   if (nParms == 3) /* If user supplied 3 parameters - this is a SET operation */
2199   {
2200       pThresholdCrossParams.uAC = parm[0].value;
2201       pThresholdCrossParams.uHighThreshold = parm[1].value;
2202       pThresholdCrossParams.uLowThreshold = parm[2].value;
2203
2204      if (pThresholdCrossParams.uLowThreshold > pThresholdCrossParams.uHighThreshold)
2205      {
2206         console_printf_terminal ("Low threshold cannot be higher than the High threshold...Aborting...\n");
2207      }
2208      else
2209      {
2210           resultCode = TI_SetMediumUsageThreshold(g_id_adapter, &pThresholdCrossParams);
2211           if (resultCode == TI_RESULT_OK)
2212           {
2213               console_printf_terminal ("Medium usage threshold for AC %d has been set to:\n LowThreshold = %d\n HighThreshold = %d\n",
2214               pThresholdCrossParams.uAC,
2215               pThresholdCrossParams.uLowThreshold,
2216               pThresholdCrossParams.uHighThreshold);
2217           }
2218           else
2219           {
2220               console_printf_terminal ("Error...\n");
2221           }
2222      }
2223
2224   }
2225   else if (nParms == 1) /* Only 1 parameter means a GET operation */
2226   {
2227      pThresholdCrossParams.uAC = parm[0].value;
2228      pThresholdCrossParams.uLowThreshold = 0;
2229      pThresholdCrossParams.uHighThreshold = 0;
2230
2231      resultCode = TI_GetMediumUsageThreshold(g_id_adapter, &pThresholdCrossParams);
2232
2233      console_printf_terminal ("Medium usage threshold for AC %d:\n LowThreshold = %d\n HighThreshold = %d\n",
2234          pThresholdCrossParams.uAC,
2235          pThresholdCrossParams.uLowThreshold,
2236          pThresholdCrossParams.uHighThreshold);
2237   }
2238
2239}
2240
2241void cmd_phy_rate_threshold(ConParm_t parm[], U16 nParms)
2242{
2243   OS_802_11_THRESHOLD_CROSS_PARAMS pThresholdCrossParams;
2244   tiUINT32 resultCode;
2245
2246   if (nParms == 3) /* If user supplied 3 parameters - this is a SET operation */
2247   {
2248       if ((is_value_rate(parm[1].value) == FALSE) || (is_value_rate(parm[2].value) == FALSE))
2249       {
2250          console_printf_terminal ("Invalid rate - PHY rate valid values are: 1,2,5,6,9,11,12,18,24,36,48,54\n");
2251          return;
2252       }
2253
2254       pThresholdCrossParams.uAC = parm[0].value;
2255       pThresholdCrossParams.uHighThreshold = parm[1].value;
2256       pThresholdCrossParams.uLowThreshold = parm[2].value;
2257
2258       if (pThresholdCrossParams.uLowThreshold > pThresholdCrossParams.uHighThreshold)
2259       {
2260          console_printf_terminal ("Low threshold cannot be higher than the High threshold...Aborting...\n");
2261       }
2262       else
2263       {
2264
2265           resultCode = TI_SetPhyRateThreshold(g_id_adapter, &pThresholdCrossParams);
2266
2267           if (resultCode == TI_RESULT_OK)
2268           {
2269              console_printf_terminal ("PHY rate threshold for AC %d has been set to:\n LowThreshold = %d\n HighThreshold = %d\n",
2270                       pThresholdCrossParams.uAC,
2271                       pThresholdCrossParams.uLowThreshold,
2272                       pThresholdCrossParams.uHighThreshold);
2273           }
2274           else
2275           {
2276              console_printf_terminal ("Error...\n");
2277           }
2278       }
2279   }
2280   else if (nParms == 1)
2281   {
2282      pThresholdCrossParams.uAC = parm[0].value;
2283      pThresholdCrossParams.uLowThreshold = 0;
2284      pThresholdCrossParams.uHighThreshold = 0;
2285
2286      resultCode = TI_GetPhyRateThreshold(g_id_adapter, &pThresholdCrossParams);
2287
2288      console_printf_terminal ("PHY rate threshold for AC %d:\n",pThresholdCrossParams.uAC);
2289      console_printf_terminal ("LowThreshold = %s\n",print_rate((rate_e) pThresholdCrossParams.uLowThreshold));
2290      console_printf_terminal ("HighThreshold = %s\n",print_rate((rate_e) pThresholdCrossParams.uHighThreshold));
2291   }
2292
2293}
2294
2295void cmd_traffic_intensity_threshold(ConParm_t parm[], U16 nParms)
2296{
2297   OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS pTrafficIntensityThresholds;
2298   tiUINT32 resultCode;
2299
2300   if (nParms == 3)
2301   {
2302      pTrafficIntensityThresholds.uHighThreshold = parm[0].value;
2303      pTrafficIntensityThresholds.uLowThreshold = parm[1].value;
2304      pTrafficIntensityThresholds.TestInterval = parm[2].value;
2305
2306      if (pTrafficIntensityThresholds.uLowThreshold >= pTrafficIntensityThresholds.uHighThreshold)
2307      {
2308         console_printf_terminal ("Error: low threshold equal or greater than the high threshold...aborting...\n");
2309      }
2310
2311      resultCode = TI_SetTrafficIntensityThresholds (g_id_adapter, &pTrafficIntensityThresholds);
2312
2313      if (resultCode == TI_RESULT_OK)
2314      {
2315         console_printf_terminal ("Successfully set traffic intensity thresholds...\n");
2316
2317      }
2318      else
2319      {
2320         console_printf_terminal ("Error: result code = %d\n",resultCode);
2321      }
2322   }
2323   else if (nParms == 0)
2324   {
2325      resultCode = TI_GetTrafficIntensityThresholds (g_id_adapter, &pTrafficIntensityThresholds);
2326
2327      if (resultCode == TI_RESULT_OK)
2328      {
2329         console_printf_terminal ("Traffic intensity thresholds :\n HighThreshold = %d\n LowThreshold = %d\n TestInterval = %d\n",
2330                  pTrafficIntensityThresholds.uHighThreshold,
2331                  pTrafficIntensityThresholds.uLowThreshold,
2332                  pTrafficIntensityThresholds.TestInterval);
2333      }
2334      else
2335      {
2336         console_printf_terminal ("Error: result code = %d\n",resultCode);
2337      }
2338
2339   }
2340
2341}
2342
2343void cmd_enable_traffic_events(ConParm_t parm[], U16 nParms)
2344{
2345   TI_ToggleTrafficIntensityEvents (g_id_adapter, (tiUINT32)TRUE);
2346   console_printf_terminal ("Traffic intensity thresholds enabled...\n");
2347}
2348
2349void cmd_disable_traffic_events(ConParm_t parm[], U16 nParms)
2350{
2351   TI_ToggleTrafficIntensityEvents (g_id_adapter, (tiUINT32)FALSE);
2352   console_printf_terminal ("Traffic intensity thresholds disabled...\n");
2353}
2354
2355void cmd_config_tx_classifier(ConParm_t parm[], U16 nParms)
2356{
2357    NWIF_CLSFR_ENTRY inParamsBuff[CLI_NUM_OF_TX_CLASFR_CON];
2358
2359    UINT32 inParamsBuffLen = 0;
2360    UINT8 i,ic,iv=0;
2361
2362    for( ic=0,iv=0; ic<CLI_NUM_OF_TX_CLASFR_CON; ic++)
2363    {
2364        inParamsBuff[ic].port = (UINT16 )parm[iv].value;
2365        iv++;
2366        inParamsBuff[ic].pri = (UINT16 )parm[iv].value;
2367        iv++;
2368        inParamsBuff[ic].ip = 0;
2369
2370
2371        inParamsBuffLen += sizeof(NWIF_CLSFR_ENTRY);
2372
2373    }
2374    for( i=0; i<4; i++,iv++)
2375    {
2376        for(ic=0;ic<CLI_NUM_OF_TX_CLASFR_CON;ic++)
2377        {
2378            inParamsBuff[ic].ip |= parm[iv].value << i * 8;
2379        }
2380    }
2381}
2382
2383void cmd_remove_clsfr_entry (ConParm_t parm[], U16 uParms)
2384{
2385    clsfr_tableEntry_t newUserTableEntry;
2386    int i;
2387    clsfrTypeAndSupport ClsfrType;
2388    tiINT32 res;
2389
2390    TI_GetClsfrType(g_id_adapter, &ClsfrType );
2391
2392    /* Possibly needs to be removed if we want to keep this routine working for old classifier as well */
2393    if (ClsfrType.oldVersionSupport == TRUE)
2394    {
2395      console_printf_terminal ("Old classifier support detected...Remove action disabled (use old classifier config)\n");
2396      return;
2397    }
2398
2399    if (uParms >=2)
2400        newUserTableEntry.DTag = (tiUINT8) parm[1].value;
2401
2402    switch(parm[0].value)
2403    {
2404        case D_TAG_CLSFR:
2405            console_printf_terminal("Cannot remove D_TAG classifier entry!\n");
2406            return;
2407        break;
2408        case DSCP_CLSFR:
2409            if (uParms != 3)
2410            {
2411                console_printf_terminal("DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n");
2412                return;
2413            }
2414            newUserTableEntry.Dscp.CodePoint = (tiUINT8) parm[2].value;
2415            console_printf_terminal ("Removing DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint);
2416        break;
2417        case PORT_CLSFR:
2418            if (uParms != 3)
2419            {
2420                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters(too many?)\n");
2421                return;
2422            }
2423            newUserTableEntry.Dscp.DstPortNum = (tiUINT16) parm[2].value;
2424            console_printf_terminal ("Removing PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum);
2425        break;
2426        case IPPORT_CLSFR:
2427            if (uParms != 7)
2428            {
2429                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters\n");
2430                return;
2431            }
2432            newUserTableEntry.Dscp.DstIPPort.DstPortNum = (tiUINT16) parm[2].value;
2433            newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0;
2434            for(i=0; i<4; i++)
2435                {
2436                    newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8;
2437                }
2438            console_printf_terminal ("Removing IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n",
2439                    newUserTableEntry.DTag,
2440                    newUserTableEntry.Dscp.DstIPPort.DstPortNum,
2441                    (int)parm[3].value,(int)parm[4].value,(int)parm[5].value,(int)parm[6].value);
2442            break;
2443        default:
2444            console_printf_terminal("Unknown Classifier Type - Command aborted!\n");
2445            return;
2446        break;
2447    }
2448
2449    res = TI_RemoveClassifierEntry(g_id_adapter, &newUserTableEntry);
2450    if (res)
2451    {
2452       console_printf_terminal ("Failed to remove classifier entry...return code = %d\n",res);
2453    }
2454
2455}
2456
2457void cmd_insert_clsfr_entry (ConParm_t parm[], U16 uParms)
2458{
2459    clsfr_tableEntry_t newUserTableEntry;
2460    int i;
2461    clsfrTypeAndSupport ClsfrType;
2462    tiINT32 res;
2463
2464    TI_GetClsfrType(g_id_adapter, &ClsfrType );
2465
2466    if (ClsfrType.oldVersionSupport == TRUE)
2467    {
2468      console_printf_terminal ("Old classifier support detected...Insert action disabled (use old classifier config)\n");
2469      return;
2470    }
2471
2472    if (uParms >=2)
2473        newUserTableEntry.DTag = (UINT8) parm[1].value;
2474
2475    switch(parm[0].value)
2476    {
2477        case D_TAG_CLSFR:
2478            console_printf_terminal("Cannot insert D_TAG classifier entry!\n");
2479            return;
2480        break;
2481        case DSCP_CLSFR:
2482            if (uParms != 3)
2483            {
2484                console_printf_terminal("DSCP_CLSFR Entry type, wrong number of parameters(too many?)\n");
2485                return;
2486            }
2487            newUserTableEntry.Dscp.CodePoint = (UINT8) parm[2].value;
2488            console_printf_terminal ("Inserting new DSCP_CLSFR classifier entry\nD-Tag = %d\nCodePoint = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.CodePoint);
2489        break;
2490        case PORT_CLSFR:
2491            if (uParms != 3)
2492            {
2493                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters(too many?)\n");
2494                return;
2495            }
2496            newUserTableEntry.Dscp.DstPortNum = (UINT16) parm[2].value;
2497            console_printf_terminal ("Inserting new PORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\n",newUserTableEntry.DTag,newUserTableEntry.Dscp.DstPortNum);
2498        break;
2499        case IPPORT_CLSFR:
2500            if (uParms != 7)
2501            {
2502                console_printf_terminal("PORT_CLSFR Entry type, wrong number of parameters\n");
2503                return;
2504            }
2505            newUserTableEntry.Dscp.DstIPPort.DstPortNum = (UINT16) parm[2].value;
2506            newUserTableEntry.Dscp.DstIPPort.DstIPAddress = 0;
2507            for(i=0; i<4; i++)
2508                {
2509                    newUserTableEntry.Dscp.DstIPPort.DstIPAddress |= parm[i+3].value << i * 8;
2510                }
2511            console_printf_terminal ("Inserting new IPPORT_CLSFR classifier entry\nD-Tag = %d\nPort = %d\nIP = %3d.%d.%d.%d\n",
2512                    newUserTableEntry.DTag,
2513                    newUserTableEntry.Dscp.DstIPPort.DstPortNum,
2514                    (int)parm[3].value,(int)parm[4].value,(int)parm[5].value,(int)parm[6].value);
2515            break;
2516        default:
2517            console_printf_terminal("Unknown Classifier Type - Command aborted!\n");
2518            return;
2519        break;
2520    }
2521
2522    res = TI_ConfigTxClassifier(g_id_adapter, sizeof(clsfr_tableEntry_t), (UINT8 *)&newUserTableEntry);
2523    if (res)
2524    {
2525       console_printf_terminal ("Failed to insert new classifier entry...return code = %d\n",res);
2526    }
2527
2528}
2529
2530void cmd_poll_ap_packets(ConParm_t parm[], U16 nParms)
2531{
2532   if (nParms == 0)
2533   {
2534   TI_PollApPackets (g_id_adapter);
2535   console_printf_terminal ("Poll AP packets cmd sent to driver...\n");
2536}
2537   else if (nParms == 1)
2538   {
2539      TI_PollApPacketsFromAC (g_id_adapter,parm[0].value);
2540      console_printf_terminal ("Poll AP packets (From AC %d) cmd sent to driver...\n",(int)parm[0].value);
2541   }
2542
2543}
2544
2545void cmd_modify_rate(ConParm_t parm[], U16 nParms)
2546{
2547    tiUINT32 data = 0, data1 = 0;
2548
2549    if( !TI_GetDesiredRate(g_id_adapter, &data1 ) )
2550    {
2551        TI_GetCurrentRate(g_id_adapter, &data );
2552
2553        console_printf_terminal("Rate: %s", print_rate(data));
2554        console_printf_terminal(", desired rate: %s\n", print_rate(data1));
2555    }
2556}
2557
2558
2559#if 0    /* not in use*/
2560void cmd_net_current_regdomain(ConParm_t parm[], U16 nParms)
2561{
2562    UNUSED(nParms);
2563    UNUSED(parm);
2564
2565    console_printf_terminal("not implemented...\n");
2566}
2567
2568 static named_value_t network_type_name[] = {
2569     { os802_11FH,                     "FH" } ,
2570     { os802_11DS,                     "DS" } ,
2571     { os802_11OFDM5,                  "OFDM5" } ,
2572     { os802_11OFDM24,                 "OFDM24" } ,
2573     { os802_11OFDM24_AND_5,           "OFDM24_AND_5" } ,
2574     { os802_11NetworkTypeMax,         "NetworkTypeMax" }
2575 };
2576
2577void cmd_net_network_in_use(ConParm_t parm[], U16 nParms)
2578{
2579    OS_802_11_NETWORK_TYPE data;
2580    if( !nParms )
2581    {
2582        if( !TI_GetNetworkTypeInUse(g_id_adapter, &data ) )
2583        {
2584            print_available_values(network_type_name);
2585
2586             console_printf_terminal("Cur.network: %d\n", data );
2587        }
2588    }
2589    else
2590        TI_SetNetworkTypeInUse(g_id_adapter, parm[0].value );
2591}
2592#endif /* if 0*/
2593
2594void cmd_show_tx_power_level_table(ConParm_t parm[], U16 nParms)
2595{
2596    TIWLAN_POWER_LEVEL_TABLE powerTable;
2597	int i;
2598
2599    if( !TI_GetTxPowerLevel(g_id_adapter, (tiCHAR*)&powerTable) )
2600	{
2601        console_printf_terminal("Power level table (Dbm/10)\n");
2602		for ( i = 0 ; i < TI_NUM_OF_SUB_BANDS ; i++)
2603		{
2604			console_printf_terminal("sub-band %i: %d %d %d %d\n", i,
2605			powerTable.uTxPower[i][0],
2606			powerTable.uTxPower[i][1],
2607			powerTable.uTxPower[i][2],
2608			powerTable.uTxPower[i][3]);
2609		}
2610	}
2611    else
2612	{
2613        console_printf_terminal("Tx Power level table ERROR !!!\n");
2614	}
2615}
2616void cmd_tx_power_dbm(ConParm_t parm[], U16 nParms)
2617{
2618    tiCHAR dummyData = 0;
2619
2620	if (nParms == 0)
2621	{
2622		if( !TI_GetTxPowerDbm(g_id_adapter, &dummyData))
2623		{
2624			console_printf_terminal("Tx Power (Dbm/10) = %d\n", dummyData);
2625		}
2626	}
2627    else
2628    {
2629        if (parm[0].value > MAX_TX_POWER)
2630        {
2631            console_printf_terminal("Hey !!! You should use values between %d and %d\n", MIN_TX_POWER, MAX_TX_POWER);
2632            return;
2633        }
2634        /* use U8 cast to fix compile warning */
2635        if(! TI_SetTxPowerDbm(g_id_adapter, (U8)parm[0].value) )
2636        {
2637            console_printf_terminal("Set Tx Power in DBM/10 = %d\n", parm[0].value);
2638        }
2639    }
2640}
2641
2642
2643void cmd_enableDisable_802_11d(ConParm_t parm[], U16 nParms)
2644{
2645    UINT8 data = 0;
2646    tiINT32 result;
2647
2648    result = TI_Get_802_11d(g_id_adapter, &data );
2649    if ( nParms == 0 )
2650    {
2651        if( result ==  TI_RESULT_OK)
2652        {
2653            console_printf_terminal("802_11d status=%d\n", data );
2654        }
2655    }
2656    else
2657    {
2658        result = TI_EnableDisable_802_11d(g_id_adapter, (UINT8) parm[0].value);
2659        if ((result != TI_RESULT_OK) && (!parm[0].value))
2660        {
2661            result = TI_Get_802_11h(g_id_adapter, &data );
2662            if (data)
2663            {
2664                console_printf_terminal("802_11d cannot be disabled while 802_11h is enabled!!\n" );
2665            }
2666        }
2667        else
2668        {
2669            console_printf_terminal("802_11d status is updated to =%d\n", parm[0].value );
2670        }
2671
2672    }
2673
2674
2675}
2676
2677void cmd_enableDisable_802_11h(ConParm_t parm[], U16 nParms)
2678{
2679    UINT8 data = 0;
2680    tiINT32 result;
2681
2682    result = TI_Get_802_11h(g_id_adapter, &data );
2683    if( nParms == 0 )
2684    {
2685        if( result ==  TI_RESULT_OK)
2686        {
2687            console_printf_terminal("802_11h status=%d\n", data );
2688        }
2689    }
2690    else
2691    {
2692        TI_EnableDisable_802_11h(g_id_adapter, (UINT8) parm[0].value);
2693        if (parm[0].value)
2694        {
2695            console_printf_terminal("802_11h enables automatically 802_11d!!\n" );
2696        }
2697
2698        console_printf_terminal("802_11h status is updated to =%d\n", parm[0].value );
2699
2700    }
2701
2702
2703}
2704
2705void cmd_d_Country_2_4Ie(ConParm_t parm[], U16 nParms)
2706{
2707    tiINT32 result;
2708
2709    if( nParms == 0 )
2710    {
2711        UINT8   countryString[COUNTRY_STRING_LEN+1];
2712        result = TI_Get_countryIeFor2_4_Ghz(g_id_adapter, (UINT8**)&countryString );
2713        if( result ==  TI_RESULT_OK)
2714        {
2715            countryString[COUNTRY_STRING_LEN] = '\0';
2716            if (countryString[0] == '\0')
2717            {
2718                console_printf_terminal("802_11d Country for 2.4 GHz is not found\n");
2719            }
2720            else
2721            {
2722                console_printf_terminal("802_11d Country for 2.4 GHz is %s \n", countryString );
2723            }
2724
2725        }
2726    }
2727    else
2728    {
2729        country_t countryWorld;
2730
2731        countryWorld.elementId = COUNTRY_IE_ID;
2732        countryWorld.len = 6;
2733        memcpy( countryWorld.countryIE.CountryString,"GB ", 3);
2734        countryWorld.countryIE.tripletChannels[0].firstChannelNumber = 1;
2735        countryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 23;
2736        countryWorld.countryIE.tripletChannels[0].numberOfChannels = 11;
2737        console_printf_terminal("802_11d Start Setting GB Country for 2.4 GHz \n");
2738
2739        result = TI_Set_countryIeFor2_4_Ghz(g_id_adapter, countryWorld);
2740
2741        console_printf_terminal("802_11d Setting GB Country for 2.4 GHz, result=%d\n", result);
2742
2743    }
2744
2745
2746}
2747
2748void cmd_d_Country_5Ie(ConParm_t parm[], U16 nParms)
2749{
2750    tiINT32 result;
2751
2752    if( nParms == 0 )
2753    {
2754        UINT8   countryString[COUNTRY_STRING_LEN+1];
2755        result = TI_Get_countryIeFor5_Ghz(g_id_adapter, (UINT8**)&countryString );
2756        if( result ==  TI_RESULT_OK)
2757        {
2758            countryString[COUNTRY_STRING_LEN] = '\0';
2759            if (countryString[0] == '\0')
2760            {
2761                console_printf_terminal("802_11d Country for 5 GHz is not found\n");
2762            }
2763            else
2764            {
2765                console_printf_terminal("802_11d Country for 5 GHz is %s\n", countryString );
2766            }
2767        }
2768    }
2769    else
2770    {
2771        country_t countryWorld;
2772
2773        countryWorld.elementId = COUNTRY_IE_ID;
2774        countryWorld.len = 6;
2775        memcpy( countryWorld.countryIE.CountryString,"US ", 3);
2776        countryWorld.countryIE.tripletChannels[0].firstChannelNumber = 36;
2777        countryWorld.countryIE.tripletChannels[0].maxTxPowerLevel = 16;
2778        countryWorld.countryIE.tripletChannels[0].numberOfChannels = 8;
2779        result = TI_Set_countryIeFor5_Ghz(g_id_adapter, countryWorld);
2780
2781        console_printf_terminal("802_11d Setting US Country for 5 GHz, result=%d\n", result);
2782
2783    }
2784
2785}
2786
2787void cmd_DFS_range(ConParm_t parm[], U16 nParms)
2788{
2789    tiINT32 result;
2790    DFS_ChannelRange_t DFS_ChannelRange;
2791
2792    if( nParms == 0 )
2793    {
2794
2795        result = TI_Get_minMaxDfsChannels(g_id_adapter, &DFS_ChannelRange );
2796        if( result ==  TI_RESULT_OK)
2797        {
2798            console_printf_terminal("DFS min channel is %d, DFS max channel is %d\n",
2799                                    DFS_ChannelRange.minDFS_channelNum, DFS_ChannelRange.maxDFS_channelNum);
2800        }
2801    }
2802    else
2803    {
2804        DFS_ChannelRange.minDFS_channelNum = (UINT16) parm[0].value;
2805        DFS_ChannelRange.maxDFS_channelNum = (UINT16) parm[1].value;
2806
2807        console_printf_terminal("Given params: min channel %d, DFS max channel %d\n",
2808                                parm[0].value, parm[1].value);
2809
2810        result = TI_Set_minMaxDfsChannels(g_id_adapter, DFS_ChannelRange);
2811        if (result ==  TI_RESULT_OK)
2812        {
2813            console_printf_terminal("Setting DFS min channel %d, DFS max channel %d\n",
2814                                    DFS_ChannelRange.minDFS_channelNum, DFS_ChannelRange.maxDFS_channelNum);
2815        }
2816        else
2817        {
2818            console_printf_terminal("Setting DFS min channel %d, DFS max channel %d - FAILED !!\n",
2819                                    DFS_ChannelRange.minDFS_channelNum, DFS_ChannelRange.maxDFS_channelNum);
2820        }
2821    }
2822
2823}
2824
2825#if 0
2826void cmd_modify_tx_power_value(ConParm_t parm[], U16 nParms)
2827{
2828    if( nParms == 0 )
2829    {
2830        tiUINT32 data = 1234;
2831        if( !TI_GetTxPowerValue(g_id_adapter, &data) )
2832            console_printf_terminal(  "Tx Power val = %ld\n", data);
2833    }
2834    else
2835        TI_SetTxPowerValue(g_id_adapter, parm[0].value);
2836}
2837#endif
2838
2839void cmd_show_regdomain_table(ConParm_t parm[], U16 nParms)
2840{
2841    UNUSED(nParms);
2842    UNUSED(parm);
2843    console_printf_terminal(  "not implemented ....\n");
2844}
2845
2846void cmd_modify_4x_state(ConParm_t parm[], U16 nParms)
2847{
2848    if( nParms == 0 )
2849    {
2850        tiBOOL data = FALSE;
2851        if( !TI_Get4XState(g_id_adapter, &data ) )
2852            console_printf_terminal("4x state=%s\n", data ? "True" : "False" );
2853    }
2854    else    /* param <read-only!!> */
2855        TI_Set4XState(g_id_adapter, (BOOL) parm[0].value);
2856}
2857
2858static named_value_t BSS_type[] =
2859{
2860    { os802_11IBSS,                  "AD-Hoc" },
2861    { os802_11Infrastructure,        "Infr." },
2862    { os802_11AutoUnknown,           "Auto" },
2863/*    { os802_11HighSpeedIBSS,         "HighSpeedIBSS" },*/
2864/*    { os802_11InfrastructureMax,     "Max" }*/
2865};
2866
2867void cmd_modify_bss_type(ConParm_t parm[], U16 nParms)
2868{
2869    OS_802_11_NETWORK_MODE data = 0;     //TRS:MEB use correct datatype to avoid compiler warning
2870    if( nParms == 0 )
2871    {
2872        if( !TI_GetBSSType(g_id_adapter, &data ) )
2873        {
2874            print_available_values(BSS_type);
2875
2876            console_printf_terminal("Current mode=%d\n", data );
2877        }
2878    }
2879    else    /* param <read-only!!> */
2880        TI_SetBSSType(g_id_adapter, (BOOL) parm[0].value);
2881}
2882
2883void cmd_get_driver_state(ConParm_t parm[], U16 nParms)
2884{
2885   static char stateDesc[6][100] =
2886{
2887    "DRIVER_STATE_IDLE",
2888    "DRIVER_STATE_SCANNING",
2889    "DRIVER_STATE_SELECTING",
2890    "DRIVER_STATE_CONNECTING",
2891    "DRIVER_STATE_CONNECTED",
2892    "DRIVER_STATE_DISCONNECTED",
2893};
2894   driverState_e myState;
2895
2896   TI_GetDriverState (g_id_adapter, &myState);
2897   console_printf_terminal("Driver state is %s\n", stateDesc[(UINT8)myState]);
2898}
2899
2900void cmd_modify_ext_rates_ie(ConParm_t parm[], U16 nParms)
2901{
2902    static named_value_t ExtRatesIE[] =
2903    {
2904        { DRAFT_5_AND_EARLIER,  "5_AND_EARLIER" },
2905        { DRAFT_6_AND_LATER,    "6_AND_LATER" }
2906    };
2907    if( nParms == 0 )
2908    {
2909        tiUINT32 data = 1122;
2910        if( !TI_GetExtRatesIE(g_id_adapter, &data ) )
2911        {
2912            print_available_values(ExtRatesIE);
2913            console_printf_terminal("ExtRatesIE=%u\n", data  );
2914        }
2915    }
2916    else
2917        TI_SetExtRatesIE(g_id_adapter, (tiUINT32) parm[0].value);
2918}
2919
2920
2921/*will return RSSI*/
2922void cmd_get_rsii_level(ConParm_t parm[], U16 nParms)
2923{
2924   tiINT32 rssi ;
2925   TI_GetRSSI(g_id_adapter, &rssi);
2926   console_printf_terminal("\n Current RSSI : %d\n" ,rssi)  ; // TRS:WDK - add return
2927}
2928
2929
2930/*will return SNR ratio*/
2931void cmd_get_snr_ratio(ConParm_t parm[], U16 nParms)
2932{
2933   tiUINT32 snr ;
2934   TI_GetSNR(g_id_adapter, &snr);
2935   console_printf_terminal("\n Current SNR ratio : %d\n" ,snr)  ;  // TRS:WDK - add return
2936}
2937
2938void cmd_modify_frag_threshold(ConParm_t parm[], U16 nParms)
2939{
2940    if( nParms == 0 )
2941    {
2942        tiUINT32 data = 0xfefefefe;
2943        if( !TI_GetFragmentThreshold(g_id_adapter, &data ) )
2944            console_printf_terminal("Frag. threshold=%d\n", data );
2945    }
2946    else
2947        TI_SetFragmentThreshold(g_id_adapter, parm[0].value);
2948}
2949
2950void cmd_modify_short_slot(ConParm_t parm[], U16 nParms)
2951{
2952    if( nParms == 0 )
2953    {
2954        tiUINT32 data = 0xfefefefe;
2955        if( !TI_GetShortSlot(g_id_adapter, &data ) )
2956            console_printf_terminal("Short slot=%d\n", data );
2957    }
2958    else
2959        TI_SetShortSlot(g_id_adapter, parm[0].value);
2960}
2961
2962void cmd_modify_rts_threshold(ConParm_t parm[], U16 nParms)
2963{
2964    if( nParms == 0 )
2965    {
2966        tiUINT32 data = 0xfefefefe;
2967        if( !TI_GetRTSThreshold( g_id_adapter, &data) )
2968            console_printf_terminal("RTSThreshold=%d\n", data );
2969    }
2970    else
2971        TI_SetRTSThreshold(g_id_adapter, parm[0].value);
2972}
2973
2974void cmd_modify_preamble(ConParm_t parm[], U16 nParms)
2975{
2976    if( nParms == 0 )
2977    {
2978        tiUINT32 data = 0xfefefefe;
2979        if( !TI_GetShortPreamble( g_id_adapter, &data) )
2980            console_printf_terminal("ShortPreamble=%d\n", data );
2981    }
2982    else
2983        TI_SetShortPreamble(g_id_adapter, parm[0].value);
2984}
2985
2986void cmd_modify_antenna_diversity(ConParm_t parm[], U16 nParms)
2987{
2988    TIWLAN_ANT_DIVERSITY antennaDiversityOptions;
2989
2990    antennaDiversityOptions.enableRxDiversity = (UINT8)parm[0].value;
2991    antennaDiversityOptions.rxSelectedAntenna = (UINT8)parm[1].value;
2992    antennaDiversityOptions.enableTxDiversity = (UINT8)parm[2].value;
2993    antennaDiversityOptions.txSelectedAntenna = (UINT8)parm[3].value;
2994    antennaDiversityOptions.rxTxSharedAnts = (UINT8)parm[4].value;
2995    TI_SetAntennaDiversityParams(g_id_adapter, &antennaDiversityOptions);
2996    console_printf_terminal("Antenna diversity parameters sent.\n");
2997}
2998
2999void cmd_modify_short_retry(ConParm_t parm[], U16 nParms)
3000{
3001    if( nParms == 0 )
3002    {
3003        tiUINT32 data = 0xfefefefe;
3004        if( !TI_GetShortRetry( g_id_adapter, &data) )
3005            console_printf_terminal("ShortRetry=%d\n", data );
3006    }
3007    else
3008        TI_SetShortRetry(g_id_adapter, parm[0].value);
3009}
3010
3011void cmd_modify_long_retry(ConParm_t parm[], U16 nParms)
3012{
3013    if( nParms == 0 )
3014    {
3015        tiUINT32 data = 0xfefefefe;
3016        if( !TI_GetLongRetry( g_id_adapter, &data) )
3017            console_printf_terminal("LongRetry=%d\n", data );
3018    }
3019    else
3020        TI_SetLongRetry(g_id_adapter, parm[0].value);
3021}
3022
3023void cmd_start_driver(ConParm_t parm[], U16 nParms)
3024{
3025    TI_Start( g_id_adapter );
3026}
3027
3028void cmd_stop_driver(ConParm_t parm[], U16 nParms)
3029{
3030    UNUSED(nParms);
3031    UNUSED(parm);
3032    TI_Stop(g_id_adapter);
3033}
3034static TI_HANDLE eventRegistered[IPC_EVENT_MAX];
3035
3036static named_value_t event_type[] = {
3037    { IPC_EVENT_ASSOCIATED,             "Associated" },
3038    { IPC_EVENT_DISASSOCIATED,          "Disassociated"  },
3039    { IPC_EVENT_LINK_SPEED,             "LinkSpeed" },
3040    { IPC_EVENT_AUTH_SUCC,              "Authentication Success" },
3041    { IPC_EVENT_SCAN_COMPLETE,          "ScanComplete" },
3042    { IPC_EVENT_TIMEOUT,                "Timeout" },
3043    { IPC_EVENT_CCKM_START,             "CCKM_Start" },
3044    { IPC_EVENT_MEDIA_SPECIFIC,         "Media_Specific" },
3045    { IPC_EVENT_EAPOL,                  "EAPOL" },
3046    { IPC_EVENT_BOUND,                  "Bound" },
3047    { IPC_EVENT_UNBOUND,                "Unbound" },
3048    { IPC_EVENT_PREAUTH_EAPOL,          "PreAuth EAPOL"},
3049/*  { IPC_EVENT_PER,                    "PER" },*/
3050    { IPC_EVENT_LOW_SNR,               "Low SNR" },
3051    { IPC_EVENT_LOW_RSSI,               "Low RSSI" },
3052    { IPC_EVENT_TSPEC_STATUS,           "IPC_EVENT_TSPEC_STATUS" },
3053    { IPC_EVENT_TSPEC_RATE_STATUS,      "IPC_EVENT_TSPEC_RATE_STATUS" },
3054    { IPC_EVENT_MEDIUM_TIME_CROSS,      "IPC_EVENT_MEDIUM_TIME_CROSS" },
3055    { IPC_EVENT_ROAMING_COMPLETE,       "ROAMING_COMPLETE"},
3056    { IPC_EVENT_EAP_AUTH_FAILURE,       "EAP-FAST/LEAP Auth Failed"},
3057    { IPC_EVENT_WPA2_PREAUTHENTICATION, "IPC_EVENT_WPA2_PREAUTHENTICATION" },
3058    { IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, "IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED" },
3059    { IPC_EVENT_BT_COEX_MODE, 	"IPC_EVENT_BT_COEX_MODE" },
3060
3061};
3062
3063
3064void cmd_events_register(ConParm_t parm[], U16 nParms)
3065{
3066    tiUINT32 event;
3067    IPC_EVENT_PARAMS pEvent;
3068
3069   if( nParms )
3070   {
3071        event = (tiUINT32)parm[0].value;
3072
3073        if (events_mask & (1 << event))
3074        {
3075#ifndef _WINDOWS
3076            console_printf_terminal("cmd_events_register, event is already enabled! (%d)\n", events_mask);
3077#endif
3078        }
3079        else
3080   {
3081        pEvent.uEventType       = (tiUINT32)parm[0].value;
3082        pEvent.uDeliveryType      = DELIVERY_PUSH;
3083        pEvent.pfEventCallback = cli_receive_ev;
3084#ifdef _WINDOWS
3085#endif
3086        if( !TI_RegisterEvent(g_id_adapter, &pEvent) )
3087            {
3088            eventRegistered[pEvent.uEventType] = pEvent.uEventID;
3089
3090                events_mask |= (1 << event);
3091#ifdef _WINDOWS
3092#endif
3093            }
3094        }
3095        }
3096    else
3097        {
3098#ifdef _WINDOWS
3099#else
3100		print_available_values(event_type);
3101#endif
3102    }
3103
3104        }
3105void cmd_events_unregister(ConParm_t parm[], U16 nParms)
3106{
3107    tiUINT32 event;
3108    IPC_EVENT_PARAMS pEvent;
3109
3110   if( nParms )
3111   {
3112        event = (tiUINT32)parm[0].value;
3113#ifdef _WINDOWS
3114#else
3115        pEvent.uEventType = event;
3116        pEvent.uEventID = eventRegistered[pEvent.uEventType];
3117        TI_UnRegisterEvent(g_id_adapter, &pEvent);
3118
3119        events_mask &= ~(1 << event);
3120#endif
3121    }
3122    else
3123    {
3124#ifdef _WINDOWS
3125#else
3126        print_available_values(event_type);
3127#endif
3128    }
3129}
3130
3131void cmd_get_selected_bssid_info(ConParm_t parm[], U16 nParms)
3132{
3133   OS_802_11_BSSID_EX myInfo;
3134   TI_GetSelectedBSSIDInfo(g_id_adapter, &myInfo);
3135
3136   console_printf_terminal("Selected BSSID Info:\n");
3137   console_printf_terminal("--------------------\n");
3138   console_printf_terminal("SSID: %s\n", get_ssid_string(&myInfo.Ssid));
3139   console_printf_terminal("BSSID: %02x.%02x.%02x.%02x.%02x.%02x\n",
3140          myInfo.MacAddress[0], myInfo.MacAddress[1], myInfo.MacAddress[2], myInfo.MacAddress[3], myInfo.MacAddress[4], myInfo.MacAddress[5] );
3141}
3142
3143int parseBssidIe(OS_802_11_BSSID_EX * bssid)
3144{
3145    OS_802_11_VARIABLE_IEs *pData;
3146    dot11_WME_PARAM_t *  qosParams;
3147
3148    int length;
3149    int retval = 0;
3150    /* console_printf_terminal("parseBssidIe,IElength=%d \n",bssid->IELength);*/
3151    for (
3152            length =sizeof(OS_802_11_FIXED_IEs) , pData = (OS_802_11_VARIABLE_IEs*) ((char*)bssid->IEs + sizeof(OS_802_11_FIXED_IEs));
3153            length < (int)(bssid->IELength-3);
3154            length += (pData->Length +2),pData =  (OS_802_11_VARIABLE_IEs*)((char*)bssid->IEs  + length)
3155        )
3156    {
3157        /* console_printf_terminal("ElementID=%d pData=%x length=%d length1=%d\n",pData->ElementID,pData,pData->Length,length);*/
3158        if (pData->ElementID == DOT11_WME_ELE_ID)
3159        {
3160            qosParams = (dot11_WME_PARAM_t *)pData;
3161            /* console_printf_terminal("OUIType=%x OUI =%x %x %x \n",qosParams->OUIType,qosParams->OUI[0],qosParams->OUI[1],qosParams->OUI[2]);*/
3162            if (qosParams->OUIType == dot11_WME_OUI_TYPE)
3163            {
3164                retval |= dot11_WME_OUI_TYPE;
3165            }
3166
3167
3168        }
3169    }
3170
3171
3172    return retval;
3173}
3174
3175void cmd_bssid_list(ConParm_t parm[], U16 nParms)
3176{
3177
3178    OS_802_11_BSSID_EX BssIdInfo;
3179    TI_GetSelectedBSSIDInfo(g_id_adapter, &BssIdInfo);
3180    get_bssid_list(parm, nParms, FALSE , &BssIdInfo );
3181}
3182
3183void cmd_Full_bssid_list(ConParm_t parm[], U16 nParms)
3184{
3185    OS_802_11_BSSID_EX BssIdInfo;
3186    TI_GetSelectedBSSIDInfo(g_id_adapter, &BssIdInfo);
3187    get_bssid_list(parm, nParms, TRUE , &BssIdInfo);
3188}
3189
3190/*When beacon filter is activated, the current RSSI of the connection with the AP will be displayed despite no beacons are
3191 *passed up to the driver*/
3192static void get_bssid_list(ConParm_t parm[], U16 nParms, BOOL fullBssidList , OS_802_11_BSSID_EX *pBssid)
3193{
3194    OS_802_11_BSSID_LIST_EX *list;/* = (OS_802_11_BSSID_LIST_EX *) data; */
3195    OS_802_11_BSSID_EX *bssid;
3196    tiUINT32 number_items, index;
3197    char buffer[8] ;
3198    int Qos = 0;
3199	BOOL isConnectedAp = FALSE ;   //TRS:MEB move this line earlier to avoid compile error
3200    buffer[0] ='\0';
3201
3202    UNUSED(nParms);
3203    UNUSED(parm);
3204
3205    if (fullBssidList)
3206    {
3207        if( TI_GetFullBSSIDList(g_id_adapter, &list) || !list )
3208            return ;
3209    }
3210    else
3211    {
3212    if( TI_GetBSSIDList(g_id_adapter, &list) || !list )
3213        return ;
3214    }
3215
3216
3217    bssid = &list->Bssid[0];
3218    number_items = list->NumberOfItems;
3219
3220    console_printf_terminal("BssId List: Num=%u\n", number_items );
3221
3222    if( number_items )
3223    {
3224        console_printf_terminal("%17s %7s %4s %5s %7s  %10s %s\n", "MAC", "Privacy", "Rssi", "Infra", "Channel","Qos   ", "SSID");
3225        while (number_items)
3226        {
3227            Qos = parseBssidIe(bssid);
3228
3229/*          console_printf_terminal("Qos=%d\n",Qos);*/
3230            if (Qos & dot11_WME_OUI_TYPE)
3231            {
3232                strcpy(buffer, "WME ");
3233            }
3234
3235            if (Qos == 0)
3236            {
3237                strcpy(buffer, "NONE ");
3238            }
3239
3240            if (( 0 == memcmp(pBssid->MacAddress ,bssid->MacAddress,sizeof(OS_802_11_MAC_ADDRESS)) ) &&
3241				(pBssid->NetworkTypeInUse == bssid->NetworkTypeInUse))
3242            {
3243                /*bssid->Rssi = staRssi ;*/
3244                isConnectedAp = TRUE ;
3245            }
3246            else
3247            {
3248                isConnectedAp = FALSE ;
3249            }
3250
3251            console_printf_terminal("%s %s %7u %4d %5d %7d %10s %s\n",
3252                    ( TRUE == isConnectedAp)?"*":" " ,
3253                    print_mac_2_str(bssid->MacAddress),
3254                    bssid->Privacy, bssid->Rssi,
3255                    bssid->InfrastructureMode, Freq2Chan(bssid->Configuration.Union.channel),
3256                    buffer,
3257                    get_ssid_string(&bssid->Ssid) );
3258
3259            if (fullBssidList)
3260            {
3261                console_printf_terminal("   TSF 0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x\n",
3262                      bssid->IEs[0], bssid->IEs[1], bssid->IEs[2], bssid->IEs[3],
3263                      bssid->IEs[4], bssid->IEs[5], bssid->IEs[6], bssid->IEs[7]);
3264                console_printf_terminal("   BeaconInterval 0x%02x%02x\n",  bssid->IEs[9], bssid->IEs[8]);
3265                console_printf_terminal("   Capabilities   0x%02x%02x\n",  bssid->IEs[10], bssid->IEs[11]);
3266                console_printf_terminal("   Variable IEs:\n");
3267                for (index=12; index<bssid->IELength; index++)
3268                {
3269                    if ((index-12)%8 == 0)
3270                    {
3271                        console_printf_terminal("\n   ");
3272                    }
3273                    console_printf_terminal("0x%02x ",bssid->IEs[index]);
3274
3275                }
3276                console_printf_terminal("\n");
3277            }
3278            bssid = (OS_802_11_BSSID_EX *) (((char *) bssid) + bssid->Length);
3279            number_items--;
3280        }
3281        console_printf_terminal("Infra.mode:");
3282        print_available_values(BSS_type);
3283    }
3284
3285    free(list);
3286}
3287
3288#ifdef _WINDOWS
3289#else
3290PACKED_STRUCT( OS_802_11_BSSID_EX_TEMP,
3291	tiUINT32                  Length;
3292	OS_802_11_MAC_ADDRESS     MacAddress;
3293    PACKED_UNION(Union,
3294        tiUINT8  Reserved[2];
3295        tiUINT16 Capabilities;
3296    );
3297	OS_802_11_SSID            Ssid;
3298	tiUINT32                  Privacy;
3299	OS_802_11_RSSI            Rssi;
3300	OS_802_11_NETWORK_TYPE    NetworkTypeInUse;
3301	OS_802_11_CONFIGURATION   Configuration;
3302	OS_802_11_NETWORK_MODE    InfrastructureMode;
3303	OS_802_11_RATES_EX        SupportedRates;
3304	tiUINT32                  IELength;
3305	tiUINT8                   IEs[MAX_BEACON_BODY_LENGTH+sizeof(OS_802_11_FIXED_IEs)];
3306);
3307#endif
3308
3309
3310void cmd_FullPrimaryBbssid(ConParm_t parm[], U16 nParms)
3311{
3312    OS_802_11_BSSID_EX_TEMP bssid;
3313    OS_802_11_BSSID_EX_TEMP *pBssid = &bssid;
3314    UINT32  index;
3315    char buffer[8] ;
3316    int Qos = 0;
3317    buffer[0] ='\0';
3318
3319    UNUSED(nParms);
3320    UNUSED(parm);
3321
3322    memset(pBssid, 0, sizeof(OS_802_11_BSSID_EX));
3323    pBssid->Length = sizeof(OS_802_11_BSSID_EX) + sizeof(OS_802_11_FIXED_IEs) + MAX_BEACON_BODY_LENGTH;
3324    if( TI_GetPrimaryBSSIDInfo(g_id_adapter, (OS_802_11_BSSID_EX*)pBssid))
3325            return ;
3326
3327    console_printf_terminal("Primary BssId: Length = %d, IELength=%d \n" , pBssid->Length, pBssid->IELength);
3328
3329    if (pBssid->Length > sizeof(OS_802_11_BSSID_EX) + sizeof(OS_802_11_FIXED_IEs) + MAX_BEACON_BODY_LENGTH)
3330    {
3331        console_printf_terminal("Error - Length = %d is too long!!\n", pBssid->Length);
3332        return;
3333    }
3334    if (pBssid->Length < pBssid->IELength)
3335    {
3336        console_printf_terminal("Error - IELength = %d is too long!!\n", pBssid->IELength);
3337        pBssid->IELength = 50;
3338        print_mac_2_str(pBssid->MacAddress),
3339
3340        console_printf_terminal("SSID len=%d\n", pBssid->Ssid.SsidLength);
3341
3342        return;
3343    }
3344    console_printf_terminal("%17s %7s %4s %5s %7s  %10s %s\n", "MAC", "Privacy", "Rssi", "Infra", "Channel","Qos   ", "SSID");
3345    Qos = parseBssidIe((OS_802_11_BSSID_EX*)pBssid);
3346
3347    if (Qos & dot11_WME_OUI_TYPE)
3348    {
3349        strcpy(buffer, "WME ");
3350    }
3351
3352    if (Qos == 0)
3353    {
3354        strcpy(buffer, "NONE ");
3355    }
3356
3357    console_printf_terminal("%s %7u %4d %5d %7d %10s %s\n",
3358            print_mac_2_str(pBssid->MacAddress),
3359            pBssid->Privacy, pBssid->Rssi,
3360            pBssid->InfrastructureMode, Freq2Chan(pBssid->Configuration.Union.channel),
3361            buffer,
3362            get_ssid_string(&pBssid->Ssid) );
3363
3364    {
3365        console_printf_terminal("   TSF 0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x\n",
3366              pBssid->IEs[0], pBssid->IEs[1], pBssid->IEs[2], pBssid->IEs[3],
3367              pBssid->IEs[4], pBssid->IEs[5], pBssid->IEs[6], pBssid->IEs[7]);
3368        console_printf_terminal("   BeaconInterval 0x%02x%02x\n",  pBssid->IEs[9], pBssid->IEs[8]);
3369        console_printf_terminal("   Capabilities   0x%02x%02x\n",  pBssid->IEs[10], pBssid->IEs[11]);
3370        console_printf_terminal("   Variable IEs:\n");
3371        for (index=12; index<pBssid->IELength; index++)
3372        {
3373            if ((index-12)%8 == 0)
3374            {
3375                console_printf_terminal("\n   ");
3376            }
3377            console_printf_terminal("0x%02x ",pBssid->IEs[index]);
3378
3379        }
3380        console_printf_terminal("\n");
3381    }
3382    console_printf_terminal("\nInfra.mode:");
3383    print_available_values(BSS_type);
3384}
3385
3386void cmd_file_load(ConParm_t parm[], U16 nParms)
3387{
3388    consoleRunScript((char *) parm[0].value);
3389}
3390
3391#ifdef TI_DBG
3392
3393struct report_bit_desc_t
3394{
3395    int index;
3396    char *desc;
3397};
3398
3399struct report_bit_desc_t report[] =
3400{
3401
3402    /* Set 0 */
3403    { CONFIG_MGR_MODULE_LOG,        "CONFIG_MGR" },
3404    { SME_SM_MODULE_LOG,            "SME_SM" },
3405    { SITE_MGR_MODULE_LOG,          "SITE_MGR" },
3406    { CONN_MODULE_LOG,              "CONN" },
3407    { MLME_SM_MODULE_LOG,           "MLMEE" },
3408    { AUTH_MODULE_LOG,              "AUTH" },
3409    { ASSOC_MODULE_LOG,             "ASSOC" },
3410    { RX_DATA_MODULE_LOG,           "RX_DATA" },
3411    { TX_DATA_MODULE_LOG,           "TX_DATA" },
3412    { CTRL_DATA_MODULE_LOG,         "CTRL_DATA" },
3413    { RSN_MODULE_LOG,               "RSN" },
3414    { HAL_RX_MODULE_LOG,            "HAL_RX" },
3415    { HAL_TX_MODULE_LOG,            "HAL_TX" },
3416    { HAL_CTRL_MODULE_LOG,          "HAL_CTRL" },
3417    { HAL_SECURITY_MODULE_LOG,      "HAL_SECUR" },
3418    { MEM_MGR_MODULE_LOG,           "MEM_MGR" },
3419    { REPORT_MODULE_LOG,            "REPORT" },
3420    { SITE_UPDATE_MODULE_LOG,       "SITE_UPDATE" },
3421    { REGULATORY_DOMAIN_MODULE_LOG, "REG_DOMAIN" },
3422    { MEASUREMENT_MNGR_MODULE_LOG,  "MEASUREMENT_MNGR" },
3423    { MEASUREMENT_SRV_MODULE_LOG,   "MEASUREMENT_SRV" },
3424    { SOFT_GEMINI_MODULE_LOG,       "SOFT_GEMINI" },
3425    { SC_MODULE_LOG,                "SC (Switch Channel)" },
3426    { EXC_MANAGER_MODULE_LOG,       "EXC_MANAGER" },
3427    { ROAMING_MANAGER_MODULE_LOG,   "ROAMING_MANAGER" },
3428    { QOS_MANAGER_MODULE_LOG,       "QOS_MANAGER" },
3429    { TRAFFIC_ADM_CTRL_MODULE_LOG,  "TRAFFIC_ADM_CTRL" },
3430    { POWER_MANAGER_MODULE_LOG,     "POWER_MANAGER" },
3431    { POWER_CONTROL_MODULE_LOG,     "POWER_CONTROL" },
3432    { POWER_SERVER_MODULE_LOG,      "POWER_SERVER" },
3433    { ELP_MODULE_LOG,               "ELP" },
3434    { SCR_MODULE_LOG,               "SCR" },
3435    { SCAN_SRV_MODULE_LOG,          "SCAN_SRV" },
3436    { SCAN_CNCN_MODULE_LOG,         "SCAN_CNCN" },
3437    { SCAN_MNGR_MODULE_LOG,         "SCAN_MNGR" },
3438    { GWSI_ADAPT_MODULE_LOG,        "GWSI_ADAPT" },
3439    { GWSI_ADAPT_CB_MODULE_LOG,     "GWSI_ADAPT_CB" },
3440    { CORE_ADAPT_MODULE_LOG,        "CORE_ADAPT" },
3441    { TX_HW_QUEUE_MODULE_LOG,       "TX HW QUEUE" },
3442    { TX_CTRL_BLK_MODULE_LOG,       "TX CTRL BLK" },
3443    { TX_RESULT_MODULE_LOG,         "TX RESULT" },
3444    { TNETW_IF_MODULE_LOG,          "TNETW IF" },
3445    { TNETW_ARBITER_MODULE_LOG,     "TNETW ARBITER" },
3446    { CURR_BSS_MODULE_LOG,          "CURR_BSS" },
3447    { FW_EVENT_MODULE_LOG,          "FW_EVENT" },
3448    { CMD_MBOX_MODULE_LOG,          "CMD_MBOX" },
3449	{ CMDQUEUE_MODULE_LOG,          "CMD_QUEUE" },
3450    { EVENT_MBOX_MODULE_LOG,        "EVENT_MBOX"},
3451    { TNETW_DRV_MODULE_LOG,         "TNETW DRV" },
3452	{ TNETW_XFER_MODULE_LOG,        "TX XFER" },
3453    { RECOVERY_MGR_MODULE_LOG,      "RECOVERY MGR" },
3454    { RECOVERY_CTRL_MODULE_LOG,     "RECOVERY CTRL" },
3455    { HW_INIT_MODULE_LOG,           "HW INIT" }
3456
3457};
3458
3459
3460struct rep_severity_level_t {
3461    U8 level;
3462    char *desc;
3463};
3464
3465static struct rep_severity_level_t report_severity_level[] = {
3466    { 0,                          "----"           },
3467    { WLAN_SEVERITY_INIT,         "INIT",          },
3468    { WLAN_SEVERITY_INFORMATION,  "INFORMATION",   },
3469    { WLAN_SEVERITY_WARNING,      "WARNING",       },
3470    { WLAN_SEVERITY_ERROR,        "ERROR",         },
3471    { WLAN_SEVERITY_FATAL_ERROR,  "FATAL_ERROR",   },
3472    { WLAN_SEVERITY_SM,           "SM",            },
3473    { WLAN_SEVERITY_CONSOLE,      "CONSOLE",       },
3474    { WLAN_SEVERITY_DEBUG_RX,     "DEBUG RX",      },
3475    { WLAN_SEVERITY_DEBUG_TX,     "DEBUG TX",      },
3476    { WLAN_SEVERITY_DEBUG_CONTROL,"DEBUG CONTROL", },
3477    { WLAN_SEVERITY_GWSI_RECORDING,"GWSI RECORDING"}
3478};
3479
3480static void print_report_module_desc(void)
3481{
3482    int i;
3483    tiUINT8 module_table[WLAN_MAX_LOG_MODULES];
3484
3485    if (!TI_GetReportModule(g_id_adapter, module_table))
3486    {
3487        console_printf_terminal("-------------------------------\n");
3488        console_printf_terminal("%.5s\tState\t %s\n", "Index", "Desc");
3489
3490        for( i = 0; i < SIZE_ARR(report); i++)
3491        {
3492            /* Check if there is string content (the first character is not ZERO) */
3493            if( report[i].desc[0] )
3494            {
3495                console_printf_terminal("%3d\t%c\t%s\n", report[i].index, (module_table[i] == '1') ? '+' : ' ', report[i].desc );
3496            }
3497        }
3498    }
3499    else
3500    {
3501        console_printf_terminal("Error reading the report table form the driver\n");
3502    }
3503}
3504
3505void cmd_report_add(ConParm_t parm[], U16 nParms)
3506{
3507    tiUINT8 module_table[WLAN_MAX_LOG_MODULES];
3508
3509    if( nParms != 1)
3510    {
3511        print_report_module_desc();
3512        console_printf_terminal( "* Use '%d' (max index) to set all table.\n", WLAN_MAX_LOG_MODULES);
3513    }
3514    else if(!TI_GetReportModule(g_id_adapter, module_table))
3515    {
3516        if (parm[0].value == WLAN_MAX_LOG_MODULES)
3517        {
3518            memset(module_table, '1', sizeof(module_table));
3519        }
3520        else if(parm[0].value < WLAN_MAX_LOG_MODULES)
3521        {
3522            module_table[parm[0].value] = '1';
3523        }
3524        TI_SetReportModule(g_id_adapter, module_table);
3525    }
3526}
3527
3528void cmd_report_clear(ConParm_t parm[], U16 nParms)
3529{
3530    tiUINT8 module_table[WLAN_MAX_LOG_MODULES + 1];
3531
3532    if( nParms != 1)
3533    {
3534        print_report_module_desc();
3535        console_printf_terminal( "* Use '%d' (max index) to clear all table.\n", WLAN_MAX_LOG_MODULES);
3536    }
3537    else if(!TI_GetReportModule(g_id_adapter, module_table))
3538    {
3539        if (parm[0].value == WLAN_MAX_LOG_MODULES)
3540        {
3541            memset(module_table, '0', WLAN_MAX_LOG_MODULES);
3542        }
3543        else if (parm[0].value < WLAN_MAX_LOG_MODULES)
3544        {
3545            module_table[parm[0].value] = '0';
3546        }
3547        TI_SetReportModule(g_id_adapter, module_table);
3548    }
3549}
3550
3551void cmd_report_set(ConParm_t parm[], U16 nParms)
3552{
3553    U8 *ModuleTable = (U8 *)parm[0].value;
3554
3555    if( nParms != 1)
3556    {
3557        print_report_module_desc();
3558    }
3559    else
3560    {
3561#ifdef _WINDOWS
3562#endif /* _WINDOWS */
3563
3564        TI_SetReportModule(g_id_adapter, ModuleTable);
3565    }
3566}
3567
3568void cmd_hw_register(ConParm_t parm[], U16 nParms)
3569{
3570    tiUINT32 data;
3571
3572#ifndef _WINDOWS
3573        usleep(10 * 1000);
3574#elif defined (_WINDOWS)
3575#endif
3576
3577    if( nParms == 1 )
3578    {
3579        if( !TI_hwReadRegister(g_id_adapter, parm[0].value, &data ) )
3580        {
3581#ifdef _WINDOWS
3582#endif
3583        }
3584    }
3585    else
3586    {
3587        TI_hwWriteRegister(g_id_adapter, parm[0].value, parm[1].value );
3588    }
3589}
3590
3591void cmd_debug_driver_print(ConParm_t parm[], U16 nParms)
3592    {
3593        tiUINT32 func_id = ( nParms > 0 ) ? parm[0].value : 0;
3594        tiUINT32 opt_param = ( nParms > 1 ) ? parm[1].value : 0;
3595        tiUINT32 buf[2] = { func_id, opt_param };
3596
3597        console_printf_terminal("DRV_PRINT: FUNC:%u, PARAM:%u\n", func_id, opt_param);
3598        TI_DisplayStats(g_id_adapter, (tiUINT8 *) buf, sizeof(buf) );
3599        /* tiwlan_driver_debug_print( g_drv_name, func_id, opt_param ); */
3600}
3601
3602void cmd_debug_buffer_put(ConParm_t parm[], U16 nParms)
3603    {
3604        tiUINT32 func_id = ( nParms > 0 ) ? parm[0].value : 0;
3605        tiUINT32 opt_param = ( nParms > 1 ) ? parm[1].value : 0;
3606        tiUINT8 buf[260];  /* no more then 256 + func id */
3607
3608        if (opt_param == 0)
3609            return;
3610        *(tiUINT32*) buf = func_id;
3611        memcpy (buf + sizeof(func_id),(char *)opt_param,strlen((char *)opt_param));
3612
3613        console_printf_terminal("cmd_debug_buffer_put: FUNC:%u, PARAM:%u\n", func_id, opt_param);
3614        TI_DisplayStats(g_id_adapter, (tiUINT8 *) buf, strlen((char *)opt_param) +  sizeof(func_id));
3615        /* tiwlan_driver_debug_print( g_drv_name, func_id, opt_param ); */
3616}
3617
3618static void print_severity_table(tiUINT8 *pTable)
3619{
3620    int i;
3621
3622    console_printf_terminal("Severity:\n");
3623    console_printf_terminal("-------------------------------\n");
3624    console_printf_terminal("%14s\tState\t%s\n", "Severity level", "Desc");
3625
3626    for( i=1; i<SIZE_ARR(report_severity_level); i++ )
3627    {
3628        console_printf_terminal("%d\t%c\t%s\n", report_severity_level[i].level, (pTable[i] == '1') ? '+' : ' ',report_severity_level[i].desc );
3629    }
3630
3631    console_printf_terminal( "* Use '0' to clear all table.\n");
3632    console_printf_terminal( "* Use '%d' (max index) to set all table.\n", SIZE_ARR(report_severity_level));
3633}
3634
3635void cmd_report_severity_table(ConParm_t parm[], U16 nParms)
3636{
3637    U8 *pSeverityTable = (U8 *)parm[0].value;
3638    tiUINT8 SeverityTable[WLAN_MAX_SEVERITIES];
3639#ifdef _WINDOWS
3640#endif /* _WINDOWS */
3641    if( nParms != 1)
3642    {
3643        if (!TI_GetReportSeverity( g_id_adapter, &SeverityTable[0]))
3644        {
3645            print_severity_table(SeverityTable);
3646        }
3647    }
3648    else
3649    {
3650        TI_SetReportSeverity(g_id_adapter, pSeverityTable);
3651    }
3652}
3653
3654void cmd_report_severity_level(ConParm_t parm[], U16 nParms)
3655{
3656    tiUINT8 SeverityTable[WLAN_MAX_SEVERITIES];
3657
3658    /* Get the current report severity */
3659    if (!TI_GetReportSeverity( g_id_adapter, &SeverityTable[0]))
3660    {
3661        if(nParms == 0)
3662        {
3663            /* Parameters error - print the current table values */
3664            print_severity_table(SeverityTable);
3665        }
3666        else
3667        {
3668            if (parm[0].value == 0)
3669            {
3670                /* Disable all severity levels */
3671
3672                memset(SeverityTable, (int)('0'), sizeof(SeverityTable));
3673
3674                TI_SetReportSeverity(g_id_adapter, SeverityTable);
3675            }
3676            else if (parm[0].value == SIZE_ARR(report_severity_level))
3677            {
3678                /* Enable all severity levels */
3679
3680                memset(SeverityTable, (int)('1'), sizeof(SeverityTable));
3681
3682                TI_SetReportSeverity(g_id_adapter, SeverityTable);
3683            }
3684            else if (parm[0].value < SIZE_ARR(report_severity_level))
3685            {
3686                console_printf_terminal("Toggle severity level %#lx\n", parm[0].value);
3687
3688                if (SeverityTable[parm[0].value] == '1')
3689                {
3690                    /* The level is enabled - Disable it */
3691                    SeverityTable[parm[0].value] = '0';
3692                }
3693                else
3694                {
3695                    /* The bit is disabled - Enable it */
3696                    SeverityTable[parm[0].value] = '1';
3697                }
3698
3699                TI_SetReportSeverity(g_id_adapter, SeverityTable);
3700            }
3701            else
3702            {
3703                console_printf_terminal("invalid level value: %#lx\n", parm[0].value );
3704            }
3705        }
3706    }
3707    else
3708    {
3709        console_printf_terminal("Error retriving the severity table from the driver\n");
3710    }
3711}
3712
3713
3714#ifdef DRIVER_PROFILING
3715
3716void cmd_profile_report(ConParm_t parm[], U16 nParms)
3717{
3718    TI_ProfileReport( g_id_adapter );
3719}
3720
3721
3722void cmd_profile_cpu_estimator_command(ConParm_t parm[], U16 nParms)
3723{
3724    /* reset or stop command */
3725    if (nParms == 1) {
3726        //printf("cpu_profile_cpu_estimator: param[0] = %d\n", (tiUINT8)parm[0].value);
3727        TI_CpuEstimatorCommand(g_id_adapter, (tiUINT8)parm[0].value, 0);
3728    }
3729    else /* start command */
3730    {
3731        //printf("cpu_profile_cpu_estimator: param[0] = %d, param[1] = %d\n",(tiUINT8)parm[0].value,(tiUINT32)parm[1].value);
3732        TI_CpuEstimatorCommand(g_id_adapter, (tiUINT8)parm[0].value,(tiUINT32)parm[1].value);
3733    }
3734}
3735
3736#endif
3737
3738void cmd_report_os_dbg_state(ConParm_t parm[], U16 nParms)
3739{
3740    UINT32 dwOsDbgState;
3741
3742    if(nParms == 0) {
3743        if (TI_GetOsDbgState( g_id_adapter, &dwOsDbgState) == TI_RESULT_OK) {
3744            console_printf_terminal("OsDbgState %d (0x%08X)\n", dwOsDbgState, dwOsDbgState);
3745        }
3746        else {
3747            console_printf_terminal("Error retriving the OsDbgState from the driver\n");
3748        }
3749    }
3750    else {
3751        TI_SetOsDbgState(g_id_adapter, parm[0].value);
3752    }
3753}
3754
3755#endif /* define TI_DBG */
3756
3757void cmd_privacy_auth(ConParm_t parm[], U16 nParms)
3758{
3759    if( nParms )
3760    {
3761        TI_SetAuthenticationMode( g_id_adapter, (tiUINT32)parm[0].value );
3762        /*console_printf_terminal("CLI-AuthenticationMode: - %x",(tiUINT32)parm[0].value);*/
3763    }
3764    else
3765    {
3766        static named_value_t auth_mode_type[] = {
3767            { os802_11AuthModeOpen,             "Open"      },
3768            { os802_11AuthModeShared,           "Shared"    },
3769            { os802_11AuthModeAutoSwitch,       "AutoSwitch"},
3770            { os802_11AuthModeWPA,              "WPA"       },
3771            { os802_11AuthModeWPAPSK,           "WPAPSK"    },
3772            { os802_11AuthModeWPANone,          "WPANone"   },
3773            { os802_11AuthModeWPA2,             "WPA2"      },
3774            { os802_11AuthModeWPA2PSK,          "WPA2PSK"   },
3775
3776            /*{ os802_11AuthModeMax,              "Max"       }*/
3777        };
3778        OS_802_11_AUTHENTICATION_MODE data;
3779
3780        if( !TI_GetAuthenticationMode( g_id_adapter, &data ) )
3781        {
3782            print_available_values(auth_mode_type);
3783            console_printf_terminal("AuthenticationMode=%d\n", data );
3784        }
3785    }
3786}
3787
3788void cmd_privacy_eap(ConParm_t parm[], U16 nParms)
3789{
3790    if( nParms )
3791    {
3792        TI_SetEAPType( g_id_adapter, (OS_802_11_EAP_TYPES) parm[0].value );
3793        TI_SetEAPTypeDriver( g_id_adapter, (OS_802_11_EAP_TYPES) parm[0].value );
3794    }
3795    else
3796    {
3797        static named_value_t eap_type[] = {
3798            { OS_EAP_TYPE_GENERIC_TOKEN_CARD,   "TOKEN" },
3799            { OS_EAP_TYPE_TLS,                  "TLS"   },
3800            INCLUDE_EXC_TYPE_NAMES
3801            { OS_EAP_TYPE_TTLS,                 "TTLS"  },
3802            { OS_EAP_TYPE_PEAP,                 "PEAP"  },
3803            {OS_EAP_TYPE_MS_CHAP_V2,            "CHAP"  }
3804        };
3805/*temp_closed
3806        OS_802_11_EAP_TYPES data;
3807
3808        if( !TI_GetEAPType( g_id_adapter, &data ) )
3809        {
3810            print_available_values(eap_type);
3811            console_printf_terminal("EAP Type = %d\n", data );
3812        }
3813*/
3814    print_available_values(eap_type);
3815    }
3816
3817}
3818
3819
3820void cmd_privacy_encrypt(ConParm_t parm[], U16 nParms)
3821{
3822   OS_802_11_ENCRYPTION_TYPES data;
3823   if( nParms )
3824    {
3825        TI_SetEncryptionType( g_id_adapter, (OS_802_11_ENCRYPTION_TYPES) parm[0].value );
3826    }
3827    else
3828    {
3829        print_available_values(encrypt_type);
3830        console_printf_terminal("Encryption=%d\n", !TI_GetEncryptionType( g_id_adapter, &data ) ? data : -1 );
3831    }
3832
3833}
3834void cmd_privacy_credent(ConParm_t parm[], U16 nParms)
3835{
3836
3837    if( nParms == 2 )
3838    {
3839        TI_SetCredentials(g_id_adapter,(tiCHAR *) parm[0].value, (tiCHAR *) parm[1].value);
3840    }
3841    else if( nParms == 1 )
3842        TI_SetCredentials(g_id_adapter,(tiCHAR *) parm[0].value, NULL);
3843    else
3844        return;
3845
3846}
3847
3848void cmd_privacy_PSKPassphrase(ConParm_t parm[], U16 nParms)
3849{
3850    char buf[PSK_BUFF_LEN], *pPassphrase;
3851    unsigned int len, is_hex_key = 0;
3852
3853
3854	if( nParms == 0 )
3855        return;
3856
3857	len = strlen((char*)(parm[0].value));
3858
3859	pPassphrase = (char*)(parm[0].value);
3860
3861	memset(buf,0,PSK_BUFF_LEN);
3862
3863    if( nParms >= 2 )
3864    {
3865#ifdef _WINDOWS
3866#else
3867        if( !stricmp((char *) parm[1].value, "hex") )
3868            is_hex_key = 1;
3869        else if(!stricmp((char *) parm[1].value, "text"))
3870            is_hex_key = 0;
3871#endif
3872    }
3873
3874    if( is_hex_key )
3875    {
3876		if( len != PSK_HEXA_LENGTH )
3877        {
3878            console_printf_terminal("The hexa PSKPassphrase must be at length of %d hexa digits \n",PSK_HEXA_LENGTH);
3879            return ;
3880        }
3881    }
3882	else
3883	{
3884		if (len > MAX_PSK_STRING_LENGTH || len < MIN_PSK_STRING_LENGTH)
3885		{
3886            console_printf_terminal("The PSKPassphrase must be between %d to  %d chars \n", MIN_PSK_STRING_LENGTH, MAX_PSK_STRING_LENGTH);
3887            return ;
3888        }
3889	}
3890
3891	memcpy(buf, (char*)(parm[0].value), len);
3892
3893	/*TI_SetPSKPassPhrase*/
3894	TI_SetPSK(g_id_adapter, (tiCHAR *)buf);
3895}
3896
3897void cmd_privacy_certificate(ConParm_t parm[], U16 nParms)
3898{
3899#ifdef _WINDOWS // TRS:HLC
3900#else
3901    console_printf_terminal("Set sertificate file : %s\n", (char*)parm[0].value);
3902    if(nParms == 1 )
3903        TI_SetCertificateParameters(g_id_adapter, (void*)parm[0].value, 0);
3904    else if(nParms == 2 )
3905        TI_SetCertificateParameters(g_id_adapter, (void*)parm[0].value,
3906                                                   (unsigned int)parm[1].value);
3907    else return;
3908#endif
3909//TRS end
3910}
3911
3912void cmd_privacy_wpa_options(ConParm_t parm[], U16 nParms)
3913{
3914    if( nParms )
3915    {
3916        TI_SetWpaOptions(g_id_adapter, parm[0].value );
3917    }
3918    else
3919    {
3920        tiUINT32 data;
3921        static named_value_t wpa_options[] = {
3922            { OS_802_11_OPTION_ENABLE_PROMOTE_MODE,   "PROMOTE_MODE" },
3923            { OS_802_11_OPTION_ENABLE_PROMOTE_CIPHER, "PROMOTE_CIPHER"   },
3924            { OS_802_11_OPTION_ENABLE_ALL,            "All" }
3925        };
3926
3927        print_available_values(wpa_options);
3928        if( !TI_GetWpaOptions(g_id_adapter, &data ) )
3929            console_printf_terminal("WPA option=%d\n", data );
3930    }
3931}
3932
3933void cmd_privacy_getdefaultkey(ConParm_t parm[], U16 nParms)
3934{
3935    tiUINT32 DefaultKeyId;
3936    if (OK == TI_GetDefaultWepKey(g_id_adapter, &DefaultKeyId))
3937        console_printf_terminal("WEP default key ID = %d\n", DefaultKeyId );
3938
3939}
3940unsigned int char_2_hexa( char c )
3941{
3942    if( c >= '0' && c <= '9' )
3943        return c - '0';
3944    else if( tolower(c) >= 'a' && tolower(c) <= 'f' )
3945        return tolower(c) - 'a' + 0x0a;
3946    console_printf_terminal("invalid symbol '%c'\n", c );
3947    return (unsigned int) -1;
3948}
3949
3950void cmd_privacy_addkey(ConParm_t parm[], U16 nParms)
3951{
3952    OS_802_11_WEP data;
3953    char *buf;
3954    unsigned int i, len, is_hex_key = 1;
3955    U32 val, val_l;
3956    unsigned int key_id = 0;
3957    unsigned int def_flag = 0;
3958
3959    buf = (char *) parm[0].value;
3960
3961    key_id = (unsigned int)parm[1].value;
3962
3963    if( parm[2].value )
3964        def_flag = 0x80000000;
3965
3966    if( nParms >= 4 )
3967    {
3968#ifdef _WINDOWS
3969#else
3970        if( !stricmp((char *) parm[3].value, "hex") )
3971            is_hex_key = 1;
3972        else if(!stricmp((char *) parm[3].value, "text"))
3973            is_hex_key = 0;
3974#endif
3975    }
3976
3977    memset(data.KeyMaterial,0,sizeof(data.KeyMaterial));
3978
3979    len = strlen(buf);
3980
3981    if( is_hex_key )
3982    {
3983        if( len % 2 )
3984        {
3985            console_printf_terminal("The hexa key should be even length\n");
3986            return ;
3987        }
3988        if(len <= 10) /*10 is number of character for key length 40 bit*/
3989            data.KeyLength = 5;
3990        else if(len <= 26) /*26 is number of character for key length 128 bit*/
3991            data.KeyLength = 13;
3992        else if(len <= 58) /*58 is number of character for key length 256 bit*/
3993            data.KeyLength = 29;
3994        else {
3995                console_printf_terminal("**Error key length\n" );
3996                return;
3997        }
3998
3999        for( i=0; *buf && i < data.KeyLength; i++ )
4000        {
4001                val = char_2_hexa(*buf);
4002                if( val == (U32) -1 )
4003                    return;
4004
4005                val_l = char_2_hexa(*(++buf));
4006                if( val_l == (U32) -1 )
4007                    return;
4008
4009                data.KeyMaterial[i] = (tiUINT8)((val << 4) | val_l);
4010                buf++;
4011        }
4012    }
4013    else        /* for ascii key */
4014    {
4015        if(len <= 5) /*10 is number of character for key length 40 bit*/
4016            data.KeyLength = 5;
4017        else if(len <= 13) /*26 is number of character for key length 128 bit*/
4018            data.KeyLength = 13;
4019        else if(len <= 29) /*58 is number of character for key length 256 bit*/
4020            data.KeyLength = 29;
4021        else {
4022                console_printf_terminal("**Error key length\n" );
4023                return;
4024        }
4025        memcpy(data.KeyMaterial, buf, len );
4026    }
4027
4028    data.KeyIndex = def_flag | key_id;
4029    data.Length = sizeof(OS_802_11_WEP);
4030
4031#ifdef DEBUG_MESSAGES
4032    console_printf_terminal("cmd_privacy_addkey len = %d, type: %s\nkey:", data.KeyLength, is_hex_key ? "hex" : "text");
4033    for(i=0; i<SIZE_ARR(data.KeyMaterial); i++ )
4034        console_printf_terminal("%02x", (U32) data.KeyMaterial[i]);
4035    console_printf_terminal("\n");
4036#endif /*DEBUG_MESSAGES */
4037    TI_AddWEPKey(g_id_adapter, &data);
4038}
4039
4040
4041void cmd_privacy_removekey(ConParm_t parm[], U16 nParms)
4042{
4043    TI_RemoveWEPKey(g_id_adapter, (U32) parm[0].value );
4044}
4045
4046void cmd_privacy_key_type(ConParm_t parm[], U16 nParms)
4047{
4048
4049   if( nParms )
4050        {
4051        TI_SetKeyType( g_id_adapter, (OS_802_11_KEY_TYPES)parm[0].value );
4052        console_printf_terminal("CLI-: KeyType - %x\n",(tiUINT32)parm[0].value);
4053        }
4054    else
4055    {
4056        static named_value_t key_type[] = {
4057            { OS_KEY_TYPE_STATIC,             "STATIC" },
4058            { OS_KEY_TYPE_DYNAMIC,            "DYNAMIC"}
4059        };
4060
4061        print_available_values(key_type);
4062    }
4063
4064}
4065void cmd_privacy_mixed_mode(ConParm_t parm[], U16 nParms)
4066{
4067    tiBOOL data;
4068
4069    if( nParms == 0 )
4070    {
4071       console_printf_terminal("Mixed Mode: 0 - FALSE, 1 - TRUE\n");
4072       data = FALSE;
4073       if( !TI_GetMixedMode(g_id_adapter, &data ) );
4074            console_printf_terminal("Mixed Mode =%s\n", data ? "True" : "False" );
4075
4076    }
4077    else    /* param <read-only!!> */
4078        TI_SetMixedMode(g_id_adapter, (BOOL) parm[0].value);
4079}
4080
4081
4082/************** Roaming Manager functions  ******************/
4083void cmd_Roaming_enable(ConParm_t parm[], U16 nParms)
4084{
4085    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4086    roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_ENABLED;
4087    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4088    console_printf_terminal("Roaming is enabled \n");
4089}
4090
4091
4092void cmd_Roaming_disable(ConParm_t parm[], U16 nParms)
4093{
4094    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4095    roamingMngrConfigParams.roamingMngrConfig.enableDisable = ROAMING_DISABLED;
4096    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4097    console_printf_terminal("Roaming is disabled \n");
4098}
4099void cmd_Roaming_lowPassFilter(ConParm_t parm[], U16 nParms)
4100{
4101    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4102    if( nParms != 0 )
4103    {
4104        roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt = (UINT16) parm[0].value;
4105    }
4106    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4107    console_printf_terminal("Time in sec to wait before low quality Roaming Triggers, \n lowPassFilterRoamingAttempt = %d sec\n",
4108           roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt);
4109}
4110
4111void cmd_Roaming_qualityIndicator(ConParm_t parm[], U16 nParms)
4112{
4113    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4114    if( nParms != 0 )
4115    {
4116        roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold = (S8) parm[0].value;
4117    }
4118    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4119    console_printf_terminal("Quality indicator (RSSI) to be used when comparing AP List matching quality, \n apQualityThreshold = %d \n",
4120           (roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold));
4121}
4122
4123
4124void cmd_Roaming_dataRetryThreshold(ConParm_t parm[], U16 nParms)
4125{
4126    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4127    if( nParms != 0 )
4128    {
4129        roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold = (UINT8) parm[0].value;
4130
4131    }
4132    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4133    console_printf_terminal("dataRetryThreshold = %d \n",
4134           roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold);
4135
4136}
4137void cmd_Roaming_numExpectedTbttForBSSLoss(ConParm_t parm[], U16 nParms)
4138{
4139    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4140    if( nParms != 0 )
4141    {
4142        roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss =  (UINT8) parm[0].value;
4143
4144    }
4145    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4146    console_printf_terminal("Number of expected TBTTs for BSS Loss event, \n numExpectedTbttForBSSLoss = %d \n",
4147           roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss);
4148
4149}
4150void cmd_Roaming_txRateThreshold(ConParm_t parm[], U16 nParms)
4151{
4152    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4153    if( nParms != 0 )
4154    {
4155        roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold =  (UINT8) parm[0].value;
4156
4157    }
4158    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4159    console_printf_terminal("txRateThreshold = %d \n",
4160           roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold);
4161
4162}
4163void cmd_Roaming_lowRssiThreshold(ConParm_t parm[], U16 nParms)
4164{
4165    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4166    if( nParms != 0 )
4167    {
4168        roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold =  (S8) parm[0].value;
4169
4170    }
4171    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4172    console_printf_terminal("lowRssiThreshold = %d \n",
4173           (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold));
4174
4175}
4176void cmd_Roaming_lowSnrThreshold(ConParm_t parm[], U16 nParms)
4177{
4178    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4179    if( nParms != 0 )
4180    {
4181        roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold =  (S8)parm[0].value;
4182
4183    }
4184    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4185    console_printf_terminal("lowSnrThreshold = %d \n", roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold);
4186}
4187void cmd_Roaming_lowQualityForBackgroungScanCondition(ConParm_t parm[], U16 nParms)
4188{
4189    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4190    if( nParms != 0 )
4191    {
4192        roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition = (S8) parm[0].value;
4193
4194    }
4195    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4196    console_printf_terminal("Indicator used to increase the background scan period when quality is low, \n lowQualityForBackgroungScanCondition = %d \n",
4197           (roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition));
4198
4199}
4200void cmd_Roaming_normalQualityForBackgroungScanCondition(ConParm_t parm[], U16 nParms)
4201{
4202    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4203    if( nParms != 0 )
4204    {
4205        roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition = (S8) parm[0].value;
4206
4207    }
4208    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4209    console_printf_terminal("Indicator used to reduce the background scan period when quality is normal, \n normalQualityForBackgroungScanCondition = %d \n",
4210           (roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition));
4211
4212}
4213
4214void cmd_Roaming_rssiFilterWeight(ConParm_t parm[], U16 nParms)
4215{
4216    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4217    if( nParms != 0 )
4218    {
4219        roamingMngrConfigParams.roamingMngrThresholdsConfig.rssiFilterWeight =  (UINT8) parm[0].value;
4220
4221    }
4222    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4223    console_printf_terminal("Rssi Filter Weight = %d \n",
4224           (roamingMngrConfigParams.roamingMngrThresholdsConfig.rssiFilterWeight));
4225}
4226
4227void cmd_Roaming_snrFilterWeight(ConParm_t parm[], U16 nParms)
4228{
4229    TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4230    if( nParms != 0 )
4231    {
4232        roamingMngrConfigParams.roamingMngrThresholdsConfig.snrFilterWeight =  (UINT8) parm[0].value;
4233
4234    }
4235    TI_SetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4236    console_printf_terminal("Snr FIlter Weight = %d \n",
4237           (roamingMngrConfigParams.roamingMngrThresholdsConfig.snrFilterWeight));
4238}
4239
4240void cmd_Roaming_getConfParams(ConParm_t parm[], U16 nParms)
4241{
4242   TI_GetRoamingConfiguration (g_id_adapter, (UINT8*)&roamingMngrConfigParams, sizeof(roamingMngrConfigParams_t));
4243
4244   console_printf_terminal("Roaming is: %s \n", roamingMngrConfigParams.roamingMngrConfig.enableDisable ? "Enabled" : "Disabled");
4245   console_printf_terminal("lowPassFilterRoamingAttempt = %d sec, apQualityThreshold = %d\n",
4246          roamingMngrConfigParams.roamingMngrConfig.lowPassFilterRoamingAttempt,
4247		  roamingMngrConfigParams.roamingMngrConfig.apQualityThreshold);
4248   console_printf_terminal("Roaming Triggers' thresholds are: \n");
4249   console_printf_terminal("dataRetryThreshold = %d, lowQualityForBackgroungScanCondition = %d, \
4250lowRssiThreshold = %d, lowSnrThreshold = %d, normalQualityForBackgroungScanCondition = %d, \
4251numExpectedTbttForBSSLoss = %d, txRateThreshold = %d \n",
4252          roamingMngrConfigParams.roamingMngrThresholdsConfig.dataRetryThreshold,
4253		  roamingMngrConfigParams.roamingMngrThresholdsConfig.lowQualityForBackgroungScanCondition,
4254		  roamingMngrConfigParams.roamingMngrThresholdsConfig.lowRssiThreshold,
4255          roamingMngrConfigParams.roamingMngrThresholdsConfig.lowSnrThreshold,
4256		  roamingMngrConfigParams.roamingMngrThresholdsConfig.normalQualityForBackgroungScanCondition,
4257          roamingMngrConfigParams.roamingMngrThresholdsConfig.numExpectedTbttForBSSLoss,
4258          roamingMngrConfigParams.roamingMngrThresholdsConfig.txRateThreshold);
4259   console_printf_terminal("RSSI / SNR filter weights are: \n");
4260   console_printf_terminal("RSSI filter weight = %d, SNR filter weight = %d\n ",
4261   		roamingMngrConfigParams.roamingMngrThresholdsConfig.rssiFilterWeight,
4262   		roamingMngrConfigParams.roamingMngrThresholdsConfig.snrFilterWeight);
4263}
4264
4265
4266void cmd_bt_coe_enable(ConParm_t parm[], U16 nParms)
4267{
4268    if( nParms == 0 )
4269    {
4270        console_printf_terminal("Please enter enable value:\n");
4271        console_printf_terminal("0 - Enable\n");
4272        console_printf_terminal("1 - Disable\n");
4273        console_printf_terminal("2 - Auto\n");
4274    }
4275    else
4276    {
4277        TI_SetBtCoeEnable(g_id_adapter, parm[0].value);
4278    }
4279}
4280
4281
4282void cmd_bt_coe_rate(ConParm_t parm[], U16 nParms)
4283{
4284    U8 Values[NUM_OF_RATES_IN_SG];
4285    U8 Index;
4286    if( nParms != NUM_OF_RATES_IN_SG )
4287    {
4288 		console_printf_terminal("0 - 1Mbps (not recommended)\n");
4289		console_printf_terminal("1 - 2Mbps (not recommended)\n");
4290		console_printf_terminal("2 - 5.5Mbps\n");
4291		console_printf_terminal("3 - 6Mbps\n");
4292		console_printf_terminal("4 - 9Mbps\n");
4293		console_printf_terminal("5 - 11Mbps\n");
4294		console_printf_terminal("6 - 12Mbps\n");
4295		console_printf_terminal("7 - 18Mbps\n");
4296		console_printf_terminal("8 - 22Mbps (not in use)\n");
4297		console_printf_terminal("9 - 24Mbps\n");
4298		console_printf_terminal("10 - 36Mbps\n");
4299		console_printf_terminal("11 - 48Mbps\n");
4300		console_printf_terminal("12 - 54Mbps\n");
4301    }
4302    else
4303    {
4304        for (Index = 0; Index < NUM_OF_RATES_IN_SG; Index++ )
4305        {
4306			Values[Index] = (U8)parm[Index].value;  //TRS:MEB use cast to fix compile warning
4307        }
4308        TI_SetBtCoeRate(g_id_adapter, Values);
4309    }
4310}
4311
4312
4313void cmd_bt_coe_config(ConParm_t parm[], U16 nParms)
4314{
4315    U32 Values[NUM_OF_CONFIG_PARAMS_IN_SG];
4316    U8 Index = 0;
4317
4318    if( nParms != NUM_OF_CONFIG_PARAMS_IN_SG )
4319    {
4320        console_printf_terminal("Please enter valid config values:\n");
4321
4322		console_printf_terminal("Param %d - wlanRxMinRateToRespectBtHp (0 - all,2,5,6,9,11,12,18,22,24,36,48,54)  \n",Index++);
4323        console_printf_terminal("Param %d - btHpMaxTime (100 - 15000)\n",Index++);
4324        console_printf_terminal("Param %d - wlanHpMaxTime (100 - 15000)\n",Index++);
4325        console_printf_terminal("Param %d - senseDisableTimer (100 - 15000)\n",Index++);
4326        console_printf_terminal("Param %d - protectiveRxTimeBeforeBtHp (10 - 2300)\n",Index++);
4327        console_printf_terminal("Param %d - protectiveTxTimeBeforeBtHp (10 - 2300)\n",Index++);
4328        console_printf_terminal("Param %d - protectiveRxTimeBeforeBtHpFastAp (10 - 20000)\n",Index++);
4329        console_printf_terminal("Param %d - protectiveTxTimeBeforeBtHpFastAp (10 - 20000)\n",Index++);
4330        console_printf_terminal("Param %d - protectiveWlanCycleTimeForFastAp (2000 - 65535)\n",Index++);
4331        console_printf_terminal("Param %d - btAntiStarvationPeriod (0 - 15000) \n",Index++);
4332        console_printf_terminal("Param %d - timeoutNextBtLpPacket (400 - 10000)\n",Index++);
4333		console_printf_terminal("Param %d - wakeUpTimeBeforeBeacon   (0 - 20000)  \n",Index++);
4334		console_printf_terminal("Param %d - hpdmMaxGuardTime   (0 - 50000)  \n",Index++);
4335		console_printf_terminal("Param %d - timeoutNextWlanPacket   (100 - 50000)  \n",Index++);
4336        console_printf_terminal("Param %d - sgAntennaType (0 - Single | 1 - Dual | 2 - Single+ )\n",Index++);
4337        console_printf_terminal("Param %d - signalingType (0 - Legacy | 1 - Palau | 2 - Other)\n",Index++);
4338        console_printf_terminal("Param %d - afhLeverageOn (0 - OFF | 1 - GPIO  | 2 - ON)\n",Index++);
4339        console_printf_terminal("Param %d - numberQuietCycle (0 - 10)\n",Index++);
4340        console_printf_terminal("Param %d - maxNumCts (0 - 10)\n",Index++);
4341        console_printf_terminal("Param %d - numberOfWlanPackets (1 - 10)\n",Index++);
4342        console_printf_terminal("Param %d - numberOfBtPackets (2 - 10)\n",Index++);
4343        console_printf_terminal("Param %d - numberOfMissedRxForAvalancheTrigger (1 - 255)\n",Index++);
4344        console_printf_terminal("Param %d - wlanElpHpSupport (0 - 1)\n",Index++);
4345        console_printf_terminal("Param %d - btAntiStarvationNumberOfCyclesWithinThePeriod (0 - 15)  \n",Index++);
4346        console_printf_terminal("Param %d - ackModeDuringBtLpInDualAnt (0 - 1)  \n",Index++);
4347        console_printf_terminal("Param %d - allowPaSdToggleDuringBtActivityEnable (0 - 1)  \n",Index++);
4348		console_printf_terminal("Param %d - sgAutoModeNoCts   (0 - 1)  \n",Index++);
4349		console_printf_terminal("Param %d - numOfBtHpRespectedReq   (0 - 20)  \n",Index++);
4350   }
4351   else
4352    {
4353        for (Index = 0; Index < NUM_OF_CONFIG_PARAMS_IN_SG; Index++ )
4354        {
4355            Values[Index] = parm[Index].value;
4356        }
4357
4358		if ( ( (is_value_rate(Values[0])) && (Values[0] != 1) ) || (Values[0] == 0) )
4359		{
4360			TI_SetBtCoeConfig(g_id_adapter, (tiUINT32 *)Values);
4361		}
4362		else
4363		{
4364			console_printf_terminal("Error: Param 26 - wlanRxMinRateToRespectBtHp (0 - all,2,5,6,9,11,12,18,22,24,36,48,54)  \n");
4365		}
4366    }
4367}
4368
4369
4370void cmd_bt_coe_get_status(ConParm_t parm[], U16 nParms)
4371{
4372    U32 Values[NUM_OF_STATUS_PARAMS_IN_SG];
4373    /* The print is done inside the module */
4374    console_printf_terminal("Done by driver - ");
4375    if( TI_SetBtCoeGetStatus(g_id_adapter,(tiUINT32 *) Values) == OK ) {
4376        console_printf_terminal("Ok\n");
4377/*      console_printf_terminal("BT Coxistence status: \n\n");
4378        console_printf_terminal("Enable: %d\n", Values[0]);
4379        console_printf_terminal("Rate: %d\n", Values[1]);
4380        console_printf_terminal("BtSignaling: %d\n", Values[2]);
4381        console_printf_terminal("BtHPMaxTime: %d\n", Values[3]);
4382        console_printf_terminal("WlanHPMaxTime: %d\n", Values[4]);
4383        console_printf_terminal("WlanEOSMaxPacket: %d\n", Values[5]);
4384        console_printf_terminal("WlanEOSMaxPacketTimeOut: %d\n", Values[6]);
4385        console_printf_terminal("BtPTAMaxPacket: %d\n", Values[7]);
4386        console_printf_terminal("BtPTAMaxPacketTimeOut: %d\n", Values[8]);
4387        console_printf_terminal("WlanSlowAPSocial: %d\n", Values[9]);
4388        console_printf_terminal("WlanSlowAPMaxCTS: %d\n", Values[10]);
4389        console_printf_terminal("WlanSlowAPMaxTimeToCTS: %d\n", Values[11]);
4390        console_printf_terminal("T8_temporary: %d\n", Values[12]);
4391        console_printf_terminal("BTtoWLANSwitchTime: %d\n", Values[13]); */
4392    }
4393    else
4394    {
4395        console_printf_terminal("Fail\n");
4396/*      console_printf_terminal("Error reading status!\n"); */
4397    }
4398}
4399
4400
4401void cmd_PLT_RxPerStart(ConParm_t parm[], U16 nParms)
4402{
4403	UINT32 Status = TI_PLT_RxPerStart(g_id_adapter);
4404	if (Status == OK)
4405		console_printf_terminal("Plt RX counters started\n");
4406	else
4407		console_printf_terminal("Plt RX counters start failed\n");
4408}
4409
4410void cmd_PLT_RxPerStop(ConParm_t parm[], U16 nParms)
4411{
4412	UINT32 Status = TI_PLT_RxPerStop(g_id_adapter);
4413	if (Status == OK)
4414		console_printf_terminal("Plt RX counters stoped\n");
4415	else
4416		console_printf_terminal("Plt RX counters stop failed\n");
4417}
4418
4419void cmd_PLT_RxPerClear(ConParm_t parm[], U16 nParms)
4420{
4421	UINT32 Status = TI_PLT_RxPerClear(g_id_adapter);
4422	if (Status == OK)
4423		console_printf_terminal("Plt RX counters cleard\n");
4424	else
4425		console_printf_terminal("Plt RX counters clear failed\n");
4426}
4427
4428void cmd_PLT_RxPerGet(ConParm_t parm[], U16 nParms)
4429{
4430	PltRxPer_t PltRxPer;
4431	UINT32 Status = TI_PLT_RxPerGetResults(g_id_adapter, &PltRxPer);
4432
4433	if (Status == OK)
4434	{
4435		console_printf_terminal("FCSErrorCount = %d\n", PltRxPer.FCSErrorCount);
4436		console_printf_terminal("PLCPErrorCount  = %d\n", PltRxPer.PLCPErrorCount);
4437        console_printf_terminal("SeqNumMissCount = %d\n", PltRxPer.SeqNumMissCount);
4438		console_printf_terminal("TotalFrameCount = %d\n", PltRxPer.TotalFrameCount);
4439	}
4440	else
4441		console_printf_terminal("Plt RX counters Get results failed\n");
4442}
4443
4444void cmd_PLT_RegisterRead(ConParm_t parm[], U16 nParms)
4445{
4446    tiUINT32 RegAddress;
4447    tiUINT32 RegValue;
4448    tiUINT32 Status;
4449    char* pTmp;
4450
4451    /* Converting hex string to tiUINT32*/
4452    pTmp = (char*)parm[0].value;
4453    sscanf(pTmp , "%x", &RegAddress);
4454
4455    /*Call the API function */
4456    Status = TI_PLT_ReadRegister(g_id_adapter, RegAddress, &RegValue);
4457    if( Status == OK )
4458        console_printf_terminal("Reg. %#lx = %#x (%d)\n", RegAddress, RegValue, RegValue );
4459}
4460
4461void cmd_PLT_RegisterWrite(ConParm_t parm[], U16 nParms)
4462{
4463    tiUINT32 RegAddress;
4464    tiUINT32 RegValue = 0;
4465    tiUINT32 Status;
4466    char* pTmp;
4467
4468    /* Converting hex string to tiUINT32*/
4469    printf("cmd_PLT_RegisterWrite\n");
4470    pTmp = (char*)parm[0].value;
4471    sscanf(pTmp, "%x", &RegAddress);
4472    pTmp = (char*)parm[1].value;
4473    sscanf(pTmp , "%x", &RegValue);
4474    printf("cmd_PLT_RegisterWrite %x %x\n", RegAddress, RegValue);
4475
4476    /*Call the API function */
4477    Status = TI_PLT_WriteRegister(g_id_adapter, RegAddress, RegValue );
4478    if (Status == OK)
4479        console_printf_terminal("Plt register 0x%x is set to 0x%x OK.\n", RegAddress, RegValue);
4480    else
4481        console_printf_terminal("Plt register 0x%x is set to 0x%x NOK.\n", RegAddress, RegValue);
4482
4483}
4484
4485
4486void cmd_PLT_TxContinues(ConParm_t parm[], U16 nParms)
4487{
4488   UINT32 Status;
4489   PltTxContinues_t PltTxContinues;
4490   if ((nParms == 0) || (nParms > 10))
4491   {
4492      console_printf_terminal("\n");
4493	  console_printf_terminal("Param 0 - Band (0 - 2.4Ghz(B/G), 1 - 5Ghz(A), 2 - Japan(4.9Ghz))\n");
4494	  console_printf_terminal("Param 1 - Channel: (1..14(2.4Ghz), 1..180(5Ghz)) \n");
4495	  console_printf_terminal("Param 2 - Rate: \n");
4496      console_printf_terminal("                1  - 1Mbps\n");
4497      console_printf_terminal("                2  - 2Mbps\n");
4498      console_printf_terminal("                3  - 5.5Mbps\n");
4499      console_printf_terminal("                4  - 11Mbps\n");
4500      console_printf_terminal("                6  - 6Mbps\n");
4501      console_printf_terminal("                7  - 9Mbps\n");
4502      console_printf_terminal("                8  - 12Mbps\n");
4503      console_printf_terminal("                9  - 18Mbps\n");
4504      console_printf_terminal("                10 - 24Mbps\n");
4505      console_printf_terminal("                11 - 36Mbps\n");
4506      console_printf_terminal("                12 - 48Mbps\n");
4507      console_printf_terminal("                13 - 54Mbps \n");
4508	  console_printf_terminal("Param 3 - preamble (0-long, 1-short)\n");
4509	  console_printf_terminal("Param 4 - Delay between packets (uSec)\n");
4510      console_printf_terminal("Param 5 - Number of TX frames (0 - endless)\n");
4511      console_printf_terminal("Param 6 - Test mode (5-Random data, 9-ZOZO(0,1,0,1,...))\n");
4512      console_printf_terminal("Param 7 - Sequance number mode(0 - fixed, 1 - incremented)\n");
4513      console_printf_terminal("Param 8 - packet Data legth [bytes] (0 - 2284)\n");
4514      console_printf_terminal("Param 9 - peer mac address: [xx:xx:xx:xx:xx:xx]\n");
4515
4516   }
4517   else
4518   {
4519	   PltTxContinues.band 	            = (UINT8) parm[0].value;
4520	   PltTxContinues.chID   	        = parm[1].value;
4521	   PltTxContinues.rate   	        = parm[2].value;
4522	   PltTxContinues.preamble	        = (UINT8) parm[3].value;
4523	   PltTxContinues.InterPacketDelay  = parm[4].value;
4524       PltTxContinues.NumOfFrames       = parm[5].value;
4525	   PltTxContinues.mode              = (UINT8) parm[6].value;
4526       PltTxContinues.aSeqNumMode       = parm[7].value;
4527       PltTxContinues.aPacketLength     = parm[8].value;
4528       hexStr2MACAddr( (char*)parm[9].value, &(PltTxContinues.aPeerMacAddr) );
4529
4530
4531	   Status = TI_PLT_TxContiues(g_id_adapter, &PltTxContinues);
4532		if (Status == OK)
4533			console_printf_terminal("OK\n");
4534		else
4535			console_printf_terminal("NOK\n");
4536
4537   }
4538}
4539
4540void cmd_PLT_TxCW(ConParm_t parm[], U16 nParms)
4541{
4542   UINT32 Status;
4543   TestCmdChannelBand_t PltTxCW;
4544
4545   if ((nParms == 0) || (nParms > 2))
4546   {
4547	  console_printf_terminal("Param 0 - Band (0 - 2.4Ghz(B/G), 1 - 5Ghz(A), 2 - Japan(4.9Ghz))\n");
4548	  console_printf_terminal("Param 1 - Channel(1..14(2.4Ghz), 1..180(5Ghz))\n");
4549   }
4550   else
4551   {
4552	   PltTxCW.band 	= (RadioBand_e) parm[0].value;
4553	   PltTxCW.channel 	= (Channel_e) parm[1].value;
4554
4555	   Status = TI_PLT_TxCW(g_id_adapter, &PltTxCW);
4556		if (Status == OK)
4557			console_printf_terminal("OK\n");
4558		else
4559			console_printf_terminal("NOK\n");
4560
4561   }
4562}
4563
4564void cmd_PLT_TxStop(ConParm_t parm[], U16 nParms)
4565{
4566	UINT32 Status = TI_PLT_TxStop(g_id_adapter);
4567	if (Status == OK)
4568		console_printf_terminal("OK\n");
4569	else
4570		console_printf_terminal("NOK\n");
4571}
4572
4573void cmd_PLT_MIB_CounterTable(ConParm_t parm[], U16 nParms)
4574{
4575    PLT_MIB_t Mib;
4576    UINT32 Status;
4577    memset(&Mib, 0, sizeof(Mib));
4578    Mib.aMib = PLT_MIB_countersTable;
4579
4580    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
4581    if (Status == OK)
4582    {
4583       console_printf_terminal("FCS error count= %d \nPLCP  error count = %d\n",
4584							   Mib.aData.CounterTable.FCSErrorCount,
4585							   Mib.aData.CounterTable.PLCPErrorCount);
4586    }
4587    else
4588    {
4589		console_printf_terminal("NOK\n");
4590    }
4591}
4592
4593void cmd_PLT_MIB_StationID(ConParm_t parm[], U16 nParms)
4594{
4595    PLT_MIB_t Mib;
4596    UINT32 Status;
4597    memset(&Mib, 0, sizeof(Mib));
4598    Mib.aMib = PLT_MIB_dot11StationId;
4599
4600    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
4601    if (Status == OK)
4602    {
4603       console_printf_terminal("MIB_StationID = %02x:%02x:%02x:%02x:%02x:%02x\n",
4604                                Mib.aData.StationId.addr[5],
4605                                Mib.aData.StationId.addr[4],
4606                                Mib.aData.StationId.addr[3],
4607                                Mib.aData.StationId.addr[2],
4608                                Mib.aData.StationId.addr[1],
4609                                Mib.aData.StationId.addr[0]);
4610    }
4611    else
4612    {
4613		console_printf_terminal("NOK\n");
4614    }
4615
4616
4617}
4618
4619
4620void cmd_modify_ctsToSelf(ConParm_t parm[], U16 nParms)
4621{
4622    PLT_MIB_t Mib;
4623    UINT32 Status;
4624    memset(&Mib, 0, sizeof(Mib));
4625    Mib.aMib = PLT_MIB_ctsToSelf;
4626
4627	if (nParms != 1)
4628	{
4629	   console_printf_terminal("CTS to self: [0 - Disable, 1 - Enable]\n");
4630	}
4631
4632	if (nParms == 0) /*Get ctsToSelf */
4633    {
4634        Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
4635        if (OK == Status)
4636            console_printf_terminal("ctsToSelf = %s (%d)\n",
4637            Mib.aData.CTSToSelfEnable?"Enable":"Disable",
4638            Mib.aData.CTSToSelfEnable);
4639    }
4640    else if (nParms == 1)
4641    {
4642        Mib.Length = sizeof(Mib.aData.CTSToSelfEnable);
4643        Mib.aData.CTSToSelfEnable = parm[0].value;
4644        if (OK != TI_PLT_WriteMIB(g_id_adapter, &Mib))
4645            console_printf_terminal("TI_PLT_WriteMIB failed\n");
4646    }
4647}
4648
4649void cmd_get_arpIpTable(ConParm_t parm[], U16 nParms)
4650{
4651    PLT_MIB_t Mib;
4652    UINT32 Status;
4653    memset(&Mib, 0, sizeof(Mib));
4654    Mib.aMib = PLT_MIB_arpIpAddressesTable;
4655    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
4656    if (OK == Status)
4657    {
4658       int FilteringEnable = Mib.aData.ArpIpAddressesTable.FilteringEnable;
4659       console_printf_terminal("ARP IP Table:\n");
4660       console_printf_terminal("FilteringEnable: %s (%d)\n",
4661           FilteringEnable?"Enable":"Disable",
4662           FilteringEnable);
4663       console_printf_terminal("ArpIpAddress: %d.%d.%d.%d\n",
4664           Mib.aData.ArpIpAddressesTable.addr[0],
4665           Mib.aData.ArpIpAddressesTable.addr[1],
4666           Mib.aData.ArpIpAddressesTable.addr[2],
4667           Mib.aData.ArpIpAddressesTable.addr[3]
4668           );
4669    }
4670}
4671
4672void cmd_get_GroupAddressTable(ConParm_t parm[], U16 nParms)
4673{
4674    PLT_MIB_t Mib;
4675    UINT32 Status;
4676    memset(&Mib, 0, sizeof(Mib));
4677    Mib.aMib = PLT_MIB_dot11GroupAddressesTable;
4678    Status = TI_PLT_ReadMIB(g_id_adapter, &Mib);
4679    if (OK == Status)
4680    {
4681       int FilteringEnable = Mib.aData.GroupAddressTable.bFilteringEnable;
4682       int i;
4683
4684       console_printf_terminal("Group addresses Table:\n");
4685       console_printf_terminal("FilteringEnable: %s (%d)\n",
4686           FilteringEnable?"Enable":"Disable",
4687           FilteringEnable);
4688       console_printf_terminal("nNumberOfAddresses: %d\n", Mib.aData.GroupAddressTable.nNumberOfAddresses);
4689       console_printf_terminal("Group addresses: \n");
4690
4691       for (i=0; i<Mib.aData.GroupAddressTable.nNumberOfAddresses; i++)
4692       console_printf_terminal("%x:%x:%x:%x:%x:%x\n",
4693           Mib.aData.GroupAddressTable.GroupTable[i].addr[0],
4694           Mib.aData.GroupAddressTable.GroupTable[i].addr[1],
4695           Mib.aData.GroupAddressTable.GroupTable[i].addr[2],
4696           Mib.aData.GroupAddressTable.GroupTable[i].addr[3],
4697           Mib.aData.GroupAddressTable.GroupTable[i].addr[4],
4698           Mib.aData.GroupAddressTable.GroupTable[i].addr[5]
4699           );
4700    }
4701}
4702
4703void cmd_PLT_TxCalGainGet(ConParm_t parm[], U16 nParms)
4704{
4705   UINT32 Status;
4706   PltGainGet_t PLTGainGet;
4707
4708   Status = TI_PLT_TxCalGainGet(g_id_adapter, &PLTGainGet);
4709   if (Status == OK)
4710   {
4711       console_printf_terminal("\n");
4712       console_printf_terminal("TxGain: %d(0x%x)\n", PLTGainGet.TxGain, PLTGainGet.TxGain);
4713       console_printf_terminal("TxUpperBound: %d(0x%x)\n", PLTGainGet.TxUpperBound, PLTGainGet.TxUpperBound);
4714       console_printf_terminal("TxLowerBound: %d(0x%x)\n", PLTGainGet.TxLowerBound, PLTGainGet.TxLowerBound);
4715   }
4716   else
4717       console_printf_terminal("NOK\n");
4718}
4719
4720
4721void cmd_PLT_TxCalGainAdjust(ConParm_t parm[], U16 nParms)
4722{
4723   UINT32 Status;
4724   UINT32 GainChange;
4725   OS_802_11_POWER_LEVELS mode;
4726
4727
4728   if ((nParms == 0) || (nParms > 1))
4729   {
4730	   console_printf_terminal("\n");
4731       console_printf_terminal("Param 0 - Gain change (db)\n");
4732   }
4733   else
4734   {
4735       GainChange = parm[0].value;
4736
4737        /* Check Power mode (works only in "awake" mode !!!) */
4738        TI_GetPowerLevelDefault(g_id_adapter, &mode );
4739        if(mode == OS_POWER_LEVEL_AWAKE)
4740        {
4741	   Status = TI_PLT_TxCalGainAdjust(g_id_adapter, GainChange);
4742		    if (Status == OK)
4743			    console_printf_terminal("OK\n");
4744		    else
4745			    console_printf_terminal("NOK\n");
4746        }
4747        else
4748        {
4749	        console_printf_terminal("Gain Adjust was not performed becouse Default power-mode is not AWAKE\n");
4750	        console_printf_terminal("Please change defaultPowerLevel parametr in tiwlan.ini file first\n");
4751        }
4752   }
4753}
4754
4755void cmd_PLT_TxCalStart(ConParm_t parm[], U16 nParms)
4756{
4757       UINT32 Status;
4758	   PltTxCalibrationRequest_t tTxStart;
4759
4760	   if (nParms != 1)
4761	   {
4762		   console_printf_terminal("\nParam 0 - Tx Power [0-255]\n");
4763	   }
4764	   else
4765	   {
4766        /* use U8 cast to fix compile warning */
4767		   tTxStart.refTxPower = (U8)parm[0].value;
4768		   Status = TI_PLT_TxCalStart(g_id_adapter,&tTxStart);
4769		   if (Status == OK)
4770			   console_printf_terminal("OK\n");
4771		   else
4772			   console_printf_terminal("NOK\n");
4773	   }
4774}
4775
4776void cmd_PLT_TxCalStop(ConParm_t parm[], U16 nParms)
4777{
4778       UINT32 Status;
4779
4780	   Status = TI_PLT_TxCalStop(g_id_adapter);
4781       if (Status == OK)
4782           console_printf_terminal("OK\n");
4783       else
4784           console_printf_terminal("NOK\n");
4785}
4786
4787void cmd_PLT_RxTxCalNVSUpdateBuffer(ConParm_t parm[], U16 nParms)
4788{
4789   UINT32 Status;
4790   PltNvsResultsBuffer_t PltNvsResultsBuffer;
4791   int i;
4792
4793   memset(&PltNvsResultsBuffer, 0, sizeof(PltNvsResultsBuffer));
4794   Status = TI_PLT_RxTxCalNVSUpdateBuffer(g_id_adapter, &PltNvsResultsBuffer);
4795   if (Status == OK)
4796   {
4797       console_printf_terminal("NVSUpdateBuffer -  number of tables:%d\n", PltNvsResultsBuffer.numOfTables);
4798       console_printf_terminal("# \t Offset\t Size\t Data\n");
4799       console_printf_terminal("###################################################################\n");
4800       for (i=0; (i<PltNvsResultsBuffer.numOfTables) && (i<NVS_RESULTS_MAX_NUM_OF_TABLES); i++)
4801       {
4802        int j;
4803        console_printf_terminal("#%d\t %p\t %.4d\t ",
4804                                i,
4805                                PltNvsResultsBuffer.tables[i].offset,
4806                                PltNvsResultsBuffer.tables[i].size);
4807        for (j=0; (j<PltNvsResultsBuffer.tables[i].size) && (j<NVS_RESULTS_MAX_UPDATE_TABLE_SIZE); j++)
4808        {
4809            console_printf_terminal("%.2x ", PltNvsResultsBuffer.tables[i].data[j]);
4810        }
4811        console_printf_terminal("\n");
4812       }
4813   }
4814   else
4815       console_printf_terminal("NOK\n");
4816}
4817
4818void cmd_PLT_RxCal(ConParm_t parm[], U16 nParms)
4819{
4820   UINT32 Status;
4821   PltRxCalibrationRequest_t PltRxCalibrationRequest;
4822   OS_802_11_POWER_LEVELS mode;
4823
4824   if ((nParms == 0) || (nParms > 5))
4825   {
4826      console_printf_terminal("\n");
4827	  console_printf_terminal("Param 0 - Expected Rssi (db)\n");
4828	  console_printf_terminal("Param 1 - Channel\n");
4829	  console_printf_terminal("Param 2 - Band (0 - 2.4Ghz(B/G), 1 - 5Ghz(A), 2 - Japan(4.9Ghz)\n");
4830      console_printf_terminal("Param 3 - Interval between samples(uSec) [100]\n");
4831      console_printf_terminal("Param 4 - Number of samples [1000]\n");
4832   }
4833   else
4834   {
4835	   PltRxCalibrationRequest.expectedRssi	= parm[0].value;
4836	   PltRxCalibrationRequest.channel = (UINT8)parm[1].value;
4837	   PltRxCalibrationRequest.band = (UINT8)parm[2].value;
4838       PltRxCalibrationRequest.intervalBetweenSamplesUsec = parm[3].value;
4839       PltRxCalibrationRequest.numOfSamples = (UINT16)parm[4].value;
4840
4841        /* Check Power mode (works only in "awake" mode !!!) */
4842        TI_GetPowerLevelDefault(g_id_adapter, &mode );
4843        if(mode == OS_POWER_LEVEL_AWAKE)
4844        {
4845	        Status = TI_PLT_RxCal(g_id_adapter, &PltRxCalibrationRequest);
4846	        if (Status == OK)
4847		        console_printf_terminal("OK\n");
4848	        else
4849		        console_printf_terminal("NOK\n");
4850        }
4851        else
4852        {
4853	        console_printf_terminal("Rx calibration was not performed becouse Default power-mode is not AWAKE\n");
4854	        console_printf_terminal("Please change defaultPowerLevel parametr in tiwlan.ini file first\n");
4855        }
4856   }
4857}
4858
4859void cmd_PLT_RadioTune(ConParm_t parm[], U16 nParms)
4860{
4861   UINT32 Status;
4862   TestCmdChannelBand_t ChannelBand;
4863   OS_802_11_POWER_LEVELS mode;
4864
4865
4866   if ((nParms == 0) || (nParms > 2))
4867   {
4868	  console_printf_terminal("Param 0 - Band (0-2.4Ghz, 1-5Ghz, 2-4.9Ghz)\n");
4869	  console_printf_terminal("Param 1 - Channel\n");
4870   }
4871   else
4872   {
4873	   ChannelBand.band 	= (RadioBand_e) parm[0].value;
4874	   ChannelBand.channel 	= (Channel_e) parm[1].value;
4875
4876	    /* Check Power mode (works only in "awake" mode !!!) */
4877        TI_GetPowerLevelDefault(g_id_adapter, &mode );
4878		if(mode == OS_POWER_LEVEL_AWAKE)
4879		{
4880			Status = TI_PLT_RadioTune(g_id_adapter, &ChannelBand);
4881			if (Status == OK)
4882				console_printf_terminal("OK\n");
4883			else
4884				console_printf_terminal("NOK\n");
4885		}
4886		else
4887		{
4888			console_printf_terminal("Radio tune was not performed becouse Default power-mode is not AWAKE\n");
4889			console_printf_terminal("Please change defaultPowerLevel parametr in tiwlan.ini file first\n");
4890		}
4891	}
4892}
4893
4894
4895#ifdef _WINDOWS
4896#endif /* ifdef _WINDOWS */
4897