Blame - CORE/HDD/src/wlan_hdd_cfg.c - platform/vendor/qcom-opensource/wlan/prima

2012-06-20 16:38:30 -0700

[diff] [blame]

3101

#endif

3102

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [burstSizeDefinition] Value = [0x%x] ",pHddCtx->cfg_ini->burstSizeDefinition);

3103

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [tsInfoAckPolicy] Value = [0x%x] ",pHddCtx->cfg_ini->tsInfoAckPolicy);

3104

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [rfSettlingTimeUs] Value = [%u] ",pHddCtx->cfg_ini->rfSettlingTimeUs);

3105

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [bSingleTidRc] Value = [%u] ",pHddCtx->cfg_ini->bSingleTidRc);

3106

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gDynamicPSPollvalue] Value = [%u] ",pHddCtx->cfg_ini->dynamicPsPollValue);

3107

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gAddTSWhenACMIsOff] Value = [%u] ",pHddCtx->cfg_ini->AddTSWhenACMIsOff);

3108

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gValidateScanList] Value = [%u] ",pHddCtx->cfg_ini->fValidateScanList);

3109

3110

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gStaKeepAlivePeriod] Value = [%u] ",pHddCtx->cfg_ini->infraStaKeepAlivePeriod);

3111

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gApDataAvailPollInterVal] Value = [%u] ",pHddCtx->cfg_ini->apDataAvailPollPeriodInMs);

3112

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableBtAmp] Value = [%u] ",pHddCtx->cfg_ini->enableBtAmp);

3113

#ifdef WLAN_BTAMP_FEATURE

3114

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [BtAmpPreferredChannel] Value = [%u] ",pHddCtx->cfg_ini->preferredChannel);

3115

#endif //WLAN_BTAMP_FEATURE

3116

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [BandCapability] Value = [%u] ",pHddCtx->cfg_ini->nBandCapability);

3117

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [fEnableBeaconEarlyTermination] Value = [%u] ",pHddCtx->cfg_ini->fEnableBeaconEarlyTermination);

3118

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [teleBcnWakeupEnable] Value = [%u] ",pHddCtx->cfg_ini->teleBcnWakeupEn);

3119

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [transListenInterval] Value = [%u] ",pHddCtx->cfg_ini->nTeleBcnTransListenInterval);

3120

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [transLiNumIdleBeacons] Value = [%u] ",pHddCtx->cfg_ini->nTeleBcnTransLiNumIdleBeacons);

3121

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [maxListenInterval] Value = [%u] ",pHddCtx->cfg_ini->nTeleBcnMaxListenInterval);

3122

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [maxLiNumIdleBeacons] Value = [%u] ",pHddCtx->cfg_ini->nTeleBcnMaxLiNumIdleBeacons);

3123

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [bcnEarlyTermWakeInterval] Value = [%u] ",pHddCtx->cfg_ini->bcnEarlyTermWakeInterval);

3124

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gApDataAvailPollInterVal] Value = [%u] ",pHddCtx->cfg_ini->apDataAvailPollPeriodInMs);

3125

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableBypass11d] Value = [%u] ",pHddCtx->cfg_ini->enableBypass11d);

3126

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableDFSChnlScan] Value = [%u] ",pHddCtx->cfg_ini->enableDFSChnlScan);

3127

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gReportMaxLinkSpeed] Value = [%u] ",pHddCtx->cfg_ini->reportMaxLinkSpeed);

3128

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [thermalMitigationEnable] Value = [%u] ",pHddCtx->cfg_ini->thermalMitigationEnable);

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

3129

#ifdef WLAN_FEATURE_11AC

3130

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gVhtChannelWidth] value = [%u]\n",pHddCtx->cfg_ini->vhtChannelWidth);

3131

#endif

3132

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [enableFirstScan2GOnly] Value = [%u] ",pHddCtx->cfg_ini->enableFirstScan2GOnly);

3133

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [skipDfsChnlInP2pSearch] Value = [%u] ",pHddCtx->cfg_ini->skipDfsChnlInP2pSearch);

3134

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [ignoreDynamicDtimInP2pMode] Value = [%u] ",pHddCtx->cfg_ini->ignoreDynamicDtimInP2pMode);

Pratik Bhalgat

2012-11-22 17:09:40 +0530

[diff] [blame]

3135

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [enableRxSTBC] Value = [%u] ",pHddCtx->cfg_ini->enableRxSTBC);

Madan Mohan Koyyalamudi

0d40e66

2012-12-07 14:24:14 -0800

[diff] [blame]

3136

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableLpwrImgTransition] Value = [%u] ",pHddCtx->cfg_ini->enableLpwrImgTransition);

Gopichand Nakkala

2013-04-26 05:45:57 -0700

[diff] [blame]

3137

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableSSR] Value = [%u] ",pHddCtx->cfg_ini->enableSSR);

Ravi Joshi

83bfaa1

2013-05-28 22:12:08 -0700

[diff] [blame]

3138

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableVhtFor24GHzBand] Value = [%u] ",pHddCtx->cfg_ini->enableVhtFor24GHzBand);

Gopichand Nakkala

2013-04-26 05:45:57 -0700

[diff] [blame]

3139

Leo Chang

64d68bc

2013-06-04 15:40:52 -0700

[diff] [blame]

3140

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableTrafficMonitor] Value = [%u] ", pHddCtx->cfg_ini->enableTrafficMonitor);

3141

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gTrafficIdleTimeout] Value = [%u] ", pHddCtx->cfg_ini->trafficIdleTimeout);

Yue Ma

0fd2387

2013-08-01 15:56:47 -0700

[diff] [blame]

3142

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gFlexConnectPowerFactor] Value = [%u] ", pHddCtx->cfg_ini->flexConnectPowerFactor);

Ravi Joshi

d2ca7c4

2013-07-23 08:37:49 -0700

[diff] [blame]

3143

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gEnableIbssHeartBeatOffload] Value = [%u] ", pHddCtx->cfg_ini->enableIbssHeartBeatOffload);

Madan Mohan Koyyalamudi

ca45457

2013-08-07 19:57:03 +0530

[diff] [blame]

3144

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gAntennaDiversity] Value = [%u] ", pHddCtx->cfg_ini->antennaDiversity);

Madan Mohan Koyyalamudi

2558bc9

2013-08-24 16:54:31 +0530

[diff] [blame]

3145

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gGoLinkMonitorPeriod] Value = [%u]",pHddCtx->cfg_ini->goLinkMonitorPeriod);

3146

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gApLinkMonitorPeriod] Value = [%u]",pHddCtx->cfg_ini->apLinkMonitorPeriod);

3147

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gGoKeepAlivePeriod] Value = [%u]",pHddCtx->cfg_ini->goKeepAlivePeriod);

3148

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gApKeepAlivePeriod]Value = [%u]",pHddCtx->cfg_ini->apKeepAlivePeriod);

krunal soni

5afa96c

2013-09-06 22:19:02 -0700

[diff] [blame]

3149

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [gAmsduSupportInAMPDU] Value = [%lu] ",pHddCtx->cfg_ini->isAmsduSupportInAMPDU);

Madan Mohan Koyyalamudi

2558bc9

2013-08-24 16:54:31 +0530

[diff] [blame]

3150

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

}

Gopichand Nakkala

2013-04-26 05:45:57 -0700

[diff] [blame]

3154

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3155

#define CFG_VALUE_MAX_LEN 256

3156

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

3157

VOS_STATUS hdd_cfg_get_config(hdd_context_t *pHddCtx, char *pBuf, int buflen)

3158

{

3159

unsigned int idx;

3160

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

3161

unsigned long cRegTableEntries = sizeof(g_registry_table) / sizeof( g_registry_table[ 0 ]);

3162

v_U32_t value;

3163

char valueStr[CFG_VALUE_MAX_LEN];

3164

char configStr[CFG_ENTRY_MAX_LEN];

3165

char *fmt;

3166

void *pField;

3167

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

3172

*pCur = '\0';

3173

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3174

for ( idx = 0; idx < cRegTableEntries; idx++, pRegEntry++ )

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3175

{

3176

pField = ( (v_U8_t *)pHddCtx->cfg_ini) + pRegEntry->VarOffset;

3177

3178

if ( ( WLAN_PARAM_Integer == pRegEntry->RegType ) ||

3179

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3180

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3181

{

3182

value = 0;

3183

memcpy( &value, pField, pRegEntry->VarSize );

3184

if ( WLAN_PARAM_HexInteger == pRegEntry->RegType )

{

fmt = "%x";

}

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

{

fmt = "%d";

}

else

{

fmt = "%u";

}

snprintf(valueStr, CFG_VALUE_MAX_LEN, fmt, value);

3197

}

3198

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3199

{

3200

snprintf(valueStr, CFG_VALUE_MAX_LEN, "%s", (char *)pField);

3201

}

3202

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3203

{

3204

pMacAddr = (v_MACADDR_t *) pField;

3205

snprintf(valueStr, CFG_VALUE_MAX_LEN,

3206

"%02x:%02x:%02x:%02x:%02x:%02x",

pMacAddr->bytes[0],

pMacAddr->bytes[1],

pMacAddr->bytes[2],

pMacAddr->bytes[3],

pMacAddr->bytes[4],

pMacAddr->bytes[5]);

}

else

{

snprintf(valueStr, CFG_VALUE_MAX_LEN, "(unhandled)");

3217

}

Sameer Thalappil

b0a3023

2013-09-27 15:37:48 -0700

[diff] [blame]

3218

curlen = scnprintf(configStr, CFG_ENTRY_MAX_LEN,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

"%s=[%s]%s\n",

pRegEntry->RegName,

valueStr,

test_bit(idx, (void *)&pHddCtx->cfg_ini->bExplicitCfg) ?

3223

"*" : "");

3224

3225

// ideally we want to return the config to the application

3226

// however the config is too big so we just printk() for now

3227

#ifdef RETURN_IN_BUFFER

3228

if (curlen <= buflen)

3229

{

3230

// copy string + '\0'

3231

memcpy(pCur, configStr, curlen+1);

3232

3233

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

3240

return VOS_STATUS_E_RESOURCES;

3241

}

3242

#else

3243

printk(KERN_CRIT "%s", configStr);

3244

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

3249

// notify application that output is in system log

3250

snprintf(pCur, buflen, "WLAN configuration written to system log");

3251

#endif // RETURN_IN_BUFFER

3252

3253

return VOS_STATUS_SUCCESS;

3254

}

3255

3256

static VOS_STATUS find_cfg_item (tCfgIniEntry* iniTable, unsigned long entries,

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3257

char *name, char** value)

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3258

{

3259

VOS_STATUS status = VOS_STATUS_E_FAILURE;

3260

unsigned long i;

3261

3262

for (i = 0; i < entries; i++) {

3263

if (strcmp(iniTable[i].name, name) == 0) {

3264

*value = iniTable[i].value;

3265

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Found %s entry for Name=[%s] Value=[%s] ",

3266

WLAN_INI_FILE, name, *value);

3267

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

3275

{

3276

if (c >= '0' && c <= '9')

3277

return c-'0';

3278

if (c >= 'a' && c <= 'f')

3279

return c-'a'+10;

3280

if (c >= 'A' && c <= 'F')

return c-'A'+10;

return 0;

}

static VOS_STATUS hdd_apply_cfg_ini( hdd_context_t *pHddCtx, tCfgIniEntry* iniTable, unsigned long entries)

3288

{

3289

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

3290

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

3291

unsigned int idx;

3292

void *pField;

3293

char *value_str = NULL;

3294

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

3299

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

3300

unsigned long cRegTableEntries = sizeof(g_registry_table) / sizeof( g_registry_table[ 0 ]);

3301

v_U32_t cbOutString;

3302

int i;

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

3303

int rv;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3304

3305

// sanity test

3306

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

3307

{

3308

hddLog(LOGE, "%s: MAX_CFG_INI_ITEMS too small, must be at least %d",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3309

__func__, cRegTableEntries);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3310

}

3311

3312

for ( idx = 0; idx < cRegTableEntries; idx++, pRegEntry++ )

3313

{

3314

//Calculate the address of the destination field in the structure.

3315

pField = ( (v_U8_t *)pStructBase )+ pRegEntry->VarOffset;

3316

3317

match_status = find_cfg_item(iniTable, entries, pRegEntry->RegName, &value_str);

3318

3319

if( (match_status != VOS_STATUS_SUCCESS) && ( pRegEntry->Flags & VAR_FLAGS_REQUIRED ) )

3320

{

3321

// If we could not read the cfg item and it is required, this is an error.

3322

hddLog(LOGE, "%s: Failed to read required config parameter %s",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3323

__func__, pRegEntry->RegName);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3324

ret_status = VOS_STATUS_E_FAILURE;

break;

}

if ( ( WLAN_PARAM_Integer == pRegEntry->RegType ) ||

3329

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

3330

{

3331

// If successfully read from the registry, use the value read.

3332

// If not, use the default value.

3333

if ( match_status == VOS_STATUS_SUCCESS && (WLAN_PARAM_Integer == pRegEntry->RegType)) {

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

3334

rv = kstrtoul(value_str, 10, &value);

3335

if (rv < 0) {

3336

hddLog(LOGE, "%s: Reg Parameter %s invalid. Enforcing default",

3337

__func__, pRegEntry->RegName);

3338

value = pRegEntry->VarDefault;

3339

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3340

}

3341

else if ( match_status == VOS_STATUS_SUCCESS && (WLAN_PARAM_HexInteger == pRegEntry->RegType)) {

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

3342

rv = kstrtoul(value_str, 16, &value);

3343

if (rv < 0) {

3344

hddLog(LOGE, "%s: Reg paramter %s invalid. Enforcing default",

3345

__func__, pRegEntry->RegName);

3346

value = pRegEntry->VarDefault;

3347

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3348

}

3349

else {

3350

value = pRegEntry->VarDefault;

3351

}

3352

3353

// If this parameter needs range checking, do it here.

3354

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

3355

{

3356

if ( value > pRegEntry->VarMax )

3357

{

3358

hddLog(LOGE, "%s: Reg Parameter %s > allowed Maximum [%lu > %lu]. Enforcing Maximum",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3359

__func__, pRegEntry->RegName, value, pRegEntry->VarMax );

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3360

value = pRegEntry->VarMax;

3361

}

3362

3363

if ( value < pRegEntry->VarMin )

3364

{

3365

hddLog(LOGE, "%s: Reg Parameter %s < allowed Minimum [%lu < %lu]. Enforcing Minimum",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3366

__func__, pRegEntry->RegName, value, pRegEntry->VarMin);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3367

value = pRegEntry->VarMin;

3368

}

3369

}

3370

// If this parameter needs range checking, do it here.

3371

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3372

{

3373

if ( value > pRegEntry->VarMax )

3374

{

3375

hddLog(LOGE, "%s: Reg Parameter %s > allowed Maximum [%lu > %lu]. Enforcing Default= %lu",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3376

__func__, pRegEntry->RegName, value, pRegEntry->VarMax, pRegEntry->VarDefault );

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3377

value = pRegEntry->VarDefault;

3378

}

3379

3380

if ( value < pRegEntry->VarMin )

3381

{

3382

hddLog(LOGE, "%s: Reg Parameter %s < allowed Minimum [%lu < %lu]. Enforcing Default= %lu",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3383

__func__, pRegEntry->RegName, value, pRegEntry->VarMin, pRegEntry->VarDefault );

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3384

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3389

memcpy( pField, &value, pRegEntry->VarSize );

3390

}

3391

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

3392

{

3393

// If successfully read from the registry, use the value read.

3394

// If not, use the default value.

3395

if (VOS_STATUS_SUCCESS == match_status)

3396

{

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

3397

rv = kstrtol(value_str, 10, &svalue);

3398

if (rv < 0) {

3399

hddLog(VOS_TRACE_LEVEL_WARN, "%s: Reg Parameter %s invalid. Enforcing Default",

3400

__func__, pRegEntry->RegName);

3401

svalue = (v_S31_t)pRegEntry->VarDefault;

3402

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

3407

}

3408

3409

// If this parameter needs range checking, do it here.

3410

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

3411

{

3412

if ( svalue > (v_S31_t)pRegEntry->VarMax )

3413

{

3414

hddLog(LOGE, "%s: Reg Parameter %s > allowed Maximum "

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3415

"[%ld > %ld]. Enforcing Maximum", __func__,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3416

pRegEntry->RegName, svalue, (int)pRegEntry->VarMax );

3417

svalue = (v_S31_t)pRegEntry->VarMax;

3418

}

3419

3420

if ( svalue < (v_S31_t)pRegEntry->VarMin )

3421

{

3422

hddLog(LOGE, "%s: Reg Parameter %s < allowed Minimum "

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3423

"[%ld < %ld]. Enforcing Minimum", __func__,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3424

pRegEntry->RegName, svalue, (int)pRegEntry->VarMin);

3425

svalue = (v_S31_t)pRegEntry->VarMin;

3426

}

3427

}

3428

// If this parameter needs range checking, do it here.

3429

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3430

{

3431

if ( svalue > (v_S31_t)pRegEntry->VarMax )

3432

{

3433

hddLog(LOGE, "%s: Reg Parameter %s > allowed Maximum "

3434

"[%ld > %ld]. Enforcing Default= %ld",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3435

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3436

(int)pRegEntry->VarMax,

3437

(int)pRegEntry->VarDefault );

3438

svalue = (v_S31_t)pRegEntry->VarDefault;

3439

}

3440

3441

if ( svalue < (v_S31_t)pRegEntry->VarMin )

3442

{

3443

hddLog(LOGE, "%s: Reg Parameter %s < allowed Minimum "

3444

"[%ld < %ld]. Enforcing Default= %ld",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3445

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3446

(int)pRegEntry->VarMin,

3447

(int)pRegEntry->VarDefault);

3448

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3453

memcpy( pField, &svalue, pRegEntry->VarSize );

3454

}

3455

// Handle string parameters

3456

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3457

{

3458

#ifdef WLAN_CFG_DEBUG

3459

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "RegName = %s, VarOffset %u VarSize %u VarDefault %s\n",

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3460

pRegEntry->RegName, pRegEntry->VarOffset, pRegEntry->VarSize, (char*)pRegEntry->VarDefault);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3461

#endif

3462

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3463

if ( match_status == VOS_STATUS_SUCCESS)

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3464

{

3465

len_value_str = strlen(value_str);

3466

3467

if(len_value_str > (pRegEntry->VarSize - 1)) {

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3468

hddLog(LOGE, "%s: Invalid Value=[%s] specified for Name=[%s] in %s\n",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3469

__func__, value_str, pRegEntry->RegName, WLAN_INI_FILE);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3470

cbOutString = utilMin( strlen( (char *)pRegEntry->VarDefault ), pRegEntry->VarSize - 1 );

3471

memcpy( pField, (void *)(pRegEntry->VarDefault), cbOutString );

3472

( (v_U8_t *)pField )[ cbOutString ] = '\0';

}

else

{

memcpy( pField, (void *)(value_str), len_value_str);

3477

( (v_U8_t *)pField )[ len_value_str ] = '\0';

3478

}

3479

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3480

else

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3481

{

3482

// Failed to read the string parameter from the registry. Use the default.

3483

cbOutString = utilMin( strlen( (char *)pRegEntry->VarDefault ), pRegEntry->VarSize - 1 );

3484

memcpy( pField, (void *)(pRegEntry->VarDefault), cbOutString );

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3485

( (v_U8_t *)pField )[ cbOutString ] = '\0';

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3486

}

3487

}

3488

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3489

{

3490

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3491

hddLog(LOGE, "%s: Invalid VarSize %u for Name=[%s]\n",

3492

__func__, pRegEntry->VarSize, pRegEntry->RegName);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3493

continue;

3494

}

3495

candidate = (char*)pRegEntry->VarDefault;

3496

if ( match_status == VOS_STATUS_SUCCESS) {

3497

len_value_str = strlen(value_str);

3498

if(len_value_str != (VOS_MAC_ADDR_SIZE*2)) {

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3499

hddLog(LOGE, "%s: Invalid MAC addr [%s] specified for Name=[%s] in %s\n",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3500

__func__, value_str, pRegEntry->RegName, WLAN_INI_FILE);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3501

}

3502

else

3503

candidate = value_str;

3504

}

3505

//parse the string and store it in the byte array

3506

for(i=0; i<VOS_MAC_ADDR_SIZE; i++)

3507

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3508

((char*)pField)[i] =

3509

(char)(parseHexDigit(candidate[i*2])*16 + parseHexDigit(candidate[i*2+1]));

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

}

}

else

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3514

hddLog(LOGE, "%s: Unknown param type for name[%s] in registry table\n",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

3515

__func__, pRegEntry->RegName);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3516

}

3517

3518

// did we successfully parse a cfg item for this parameter?

3519

if( (match_status == VOS_STATUS_SUCCESS) &&

3520

(idx < MAX_CFG_INI_ITEMS) )

3521

{

3522

set_bit(idx, (void *)&pHddCtx->cfg_ini->bExplicitCfg);

}

}

print_hdd_cfg(pHddCtx);

3527

3528

return( ret_status );

3529

}

3530

3531

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

3532

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3533

switch (dot11Mode)

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3534

{

3535

case (eHDD_DOT11_MODE_abg):

3536

return eCSR_DOT11_MODE_abg;

3537

case (eHDD_DOT11_MODE_11b):

3538

return eCSR_DOT11_MODE_11b;

3539

case (eHDD_DOT11_MODE_11g):

3540

return eCSR_DOT11_MODE_11g;

3541

default:

3542

case (eHDD_DOT11_MODE_11n):

3543

return eCSR_DOT11_MODE_11n;

3544

case (eHDD_DOT11_MODE_11g_ONLY):

3545

return eCSR_DOT11_MODE_11g_ONLY;

3546

case (eHDD_DOT11_MODE_11n_ONLY):

3547

return eCSR_DOT11_MODE_11n_ONLY;

3548

case (eHDD_DOT11_MODE_11b_ONLY):

3549

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

3550

#ifdef WLAN_FEATURE_11AC

3551

case (eHDD_DOT11_MODE_11ac_ONLY):

3552

return eCSR_DOT11_MODE_11ac_ONLY;

3553

case (eHDD_DOT11_MODE_11ac):

3554

return eCSR_DOT11_MODE_11ac;

3555

#endif

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3556

case (eHDD_DOT11_MODE_AUTO):

3557

return eCSR_DOT11_MODE_AUTO;

}

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3562

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3563

{

3564

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3565

tSmeBtcConfig btcParams;

Wilson Tsao

f8b3794

2013-09-06 10:49:00 -0700

[diff] [blame]

3566

int i;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3567

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3568

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

3569

3570

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3571

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3572

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

3573

Jeff Johnson

32d95a3

2012-09-10 13:15:23 -0700

[diff] [blame]

3574

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

3575

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

3576

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

3577

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

3578

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

3579

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

3580

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

3581

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

3582

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

3583

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

3584

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

3585

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

3586

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

3587

Wilson Tsao

f8b3794

2013-09-06 10:49:00 -0700

[diff] [blame]

3588

for (i = 0; i < 10; i++)

3589

{

3590

btcParams.mwsCoexVictimWANFreq[i] = pConfig->mwsCoexVictimWANFreq[i];

3591

btcParams.mwsCoexVictimWLANFreq[i] = pConfig->mwsCoexVictimWLANFreq[i];

3592

btcParams.mwsCoexVictimConfig[i] = pConfig->mwsCoexVictimConfig[i];

3593

btcParams.mwsCoexVictimConfig2[i] = pConfig->mwsCoexVictimConfig2[i];

3594

}

3595

for (i = 0; i < 6; i++)

3596

{

3597

btcParams.mwsCoexConfig[i] = pConfig->mwsCoexConfig[i];

3598

}

3599

btcParams.mwsCoexModemBackoff = pConfig->mwsCoexModemBackoff;

3600

btcParams.SARPowerBackoff = pConfig->SARPowerBackoff;

3601

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3602

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

3603

}

3604

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3605

static void hdd_set_power_save_config(hdd_context_t *pHddCtx, tSmeConfigParams *smeConfig)

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3606

{

3607

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3608

3609

tPmcBmpsConfigParams bmpsParams;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3610

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3611

sme_GetConfigPowerSave(pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE, &bmpsParams);

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3612

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3613

if (strcmp(pConfig->PowerUsageControl, "Min") == 0)

3614

{

3615

smeConfig->csrConfig.impsSleepTime = pConfig->nImpsMinSleepTime;

3616

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

3617

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3618

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3619

}

3620

if (strcmp(pConfig->PowerUsageControl, "Max") == 0)

3621

{

3622

smeConfig->csrConfig.impsSleepTime = pConfig->nImpsMaxSleepTime;

3623

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

3624

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3625

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3626

}

3627

if (strcmp(pConfig->PowerUsageControl, "Mod") == 0)

3628

{

3629

smeConfig->csrConfig.impsSleepTime = pConfig->nImpsModSleepTime;

3630

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

3631

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3632

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3633

}

3634

3635

if (pConfig->fIsImpsEnabled)

3636

{

3637

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

3642

}

3643

Madan Mohan Koyyalamudi

69b3418

2013-01-16 08:51:40 +0530

[diff] [blame]

3644

/*If isAndroidPsEn is 1 then Host driver and above layers control the PS mechanism

3645

If Value set to 0 Driver/Core Stack internally control the Power saving mechanism */

3646

sme_SetHostPowerSave (pHddCtx->hHal, pConfig->isAndroidPsEn);

3647

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3648

if (pConfig->fIsBmpsEnabled)

3649

{

3650

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

3655

}

3656

3657

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

3658

3659

if (sme_SetConfigPowerSave(pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE, &bmpsParams)== eHAL_STATUS_FAILURE)

3660

{

3661

hddLog(LOGE, "SetConfigPowerSave failed to set BMPS params\n");

3662

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3663

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3664

if(pConfig->fIsAutoBmpsTimerEnabled)

3665

{

3666

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3672

static VOS_STATUS hdd_string_to_u8_array( char *str, tANI_U8 *intArray, tANI_U8 *len, tANI_U8 intArrayMaxLen )

{

char *s = str;

if( str == NULL || intArray == NULL || len == NULL )

3677

{

3678

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3682

while ( (s != NULL) && (*len < intArrayMaxLen) )

3683

{

3684

int val;

3685

//Increment length only if sscanf succesfully extracted one element.

3686

//Any other return value means error. Ignore it.

3687

if( sscanf(s, "%d", &val ) == 1 )

3688

{

3689

intArray[*len] = (tANI_U8) val;

3690

*len += 1;

3691

}

3692

s = strpbrk( s, "," );

3693

if( s )

3694

s++;

3695

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3696

3697

return VOS_STATUS_SUCCESS;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3698

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

3704

{

3705

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

2013-01-03 15:45:56 -0800

[diff] [blame]

3706

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3707

tANI_U32 val;

3708

#endif

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3709

3710

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

2012-11-22 17:09:40 +0530

[diff] [blame]

3711

tSirMacHTCapabilityInfo htCapInfo;

3712

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3713

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3714

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3715

pConfig->ShortGI20MhzEnable, NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3716

{

3717

fStatus = FALSE;

3718

hddLog(LOGE, "Could not pass on WNI_CFG_SHORT_GI_20MHZ to CCM\n");

3719

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3720

3721

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_CAL_CONTROL, pConfig->Calibration,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3722

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3723

{

3724

fStatus = FALSE;

3725

hddLog(LOGE, "Could not pass on WNI_CFG_CAL_CONTROL to CCM\n");

3726

}

3727

3728

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_CAL_PERIOD, pConfig->CalibrationPeriod,

3729

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3730

{

3731

fStatus = FALSE;

3732

hddLog(LOGE, "Could not pass on WNI_CFG_CAL_PERIOD to CCM\n");

3733

}

3734

3735

if ( 0 != pConfig->Cfg1Id )

3736

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3737

if (ccmCfgSetInt(pHddCtx->hHal, pConfig->Cfg1Id, pConfig->Cfg1Value, NULL,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3738

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3739

{

3740

fStatus = FALSE;

3741

hddLog(LOGE, "Could not pass on Cfg1Id to CCM\n");

3742

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3743

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3744

}

3745

3746

if ( 0 != pConfig->Cfg2Id )

3747

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3748

if (ccmCfgSetInt(pHddCtx->hHal, pConfig->Cfg2Id, pConfig->Cfg2Value,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3749

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3750

{

3751

fStatus = FALSE;

3752

hddLog(LOGE, "Could not pass on Cfg2Id to CCM\n");

}

}

if ( 0 != pConfig->Cfg3Id )

3757

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3758

if (ccmCfgSetInt(pHddCtx->hHal, pConfig->Cfg3Id, pConfig->Cfg3Value,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3759

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3760

{

3761

fStatus = FALSE;

3762

hddLog(LOGE, "Could not pass on Cfg3Id to CCM\n");

}

}

if ( 0 != pConfig->Cfg4Id )

3767

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3768

if (ccmCfgSetInt(pHddCtx->hHal, pConfig->Cfg4Id, pConfig->Cfg4Value,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3769

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3770

{

3771

fStatus = FALSE;

3772

hddLog(LOGE, "Could not pass on Cfg4Id to CCM\n");

}

}

if ( 0 != pConfig->Cfg5Id )

3777

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3778

if (ccmCfgSetInt(pHddCtx->hHal, pConfig->Cfg5Id, pConfig->Cfg5Value,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3779

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3780

{

3781

fStatus = FALSE;

3782

hddLog(LOGE, "Could not pass on Cfg5Id to CCM\n");

}

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3786

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_BA_AUTO_SETUP, pConfig->BlockAckAutoSetup,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3787

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3788

{

3789

fStatus = FALSE;

3790

hddLog(LOGE, "Could not pass on WNI_CFG_BA_AUTO_SETUP to CCM\n");

3791

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3792

3793

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_FIXED_RATE, pConfig->TxRate,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3794

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3795

{

3796

fStatus = FALSE;

3797

hddLog(LOGE, "Could not pass on WNI_CFG_FIXED_RATE to CCM\n");

3798

}

3799

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3800

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3801

pConfig->MaxRxAmpduFactor, NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3802

{

3803

fStatus = FALSE;

3804

hddLog(LOGE,"Could not pass on WNI_CFG_HT_AMPDU_PARAMS_MAX_RX_AMPDU_FACTOR to CCM\n");

3805

}

3806

3807

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_PREAMBLE, pConfig->fIsShortPreamble,

3808

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3809

{

3810

fStatus = FALSE;

3811

hddLog(LOGE,"Could not pass on WNI_CFG_SHORT_PREAMBLE to CCM\n");

3812

}

3813

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3814

if (pConfig->fIsAutoIbssBssid)

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3815

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3816

if (ccmCfgSetStr(pHddCtx->hHal, WNI_CFG_BSSID, (v_U8_t *)"000000000000",

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3817

sizeof(v_BYTE_t) * VOS_MAC_ADDR_SIZE, NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3818

{

3819

fStatus = FALSE;

3820

hddLog(LOGE,"Could not pass on WNI_CFG_BSSID to CCM\n");

3821

}

3822

}

3823

else

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3824

{

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3825

if ( VOS_FALSE == vos_is_macaddr_group( &pConfig->IbssBssid ))

3826

{

3827

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3828

"MAC Addr (IBSS BSSID) read from Registry is: %02x-%02x-%02x-%02x-%02x-%02x",

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3829

pConfig->IbssBssid.bytes[0], pConfig->IbssBssid.bytes[1], pConfig->IbssBssid.bytes[2],

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3830

pConfig->IbssBssid.bytes[3], pConfig->IbssBssid.bytes[4], pConfig->IbssBssid.bytes[5]);

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3831

if (ccmCfgSetStr(pHddCtx->hHal, WNI_CFG_BSSID, pConfig->IbssBssid.bytes,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3832

sizeof(v_BYTE_t) * VOS_MAC_ADDR_SIZE, NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3833

{

3834

fStatus = FALSE;

3835

hddLog(LOGE,"Could not pass on WNI_CFG_BSSID to CCM\n");

}

}

else

{

fStatus = FALSE;

hddLog(LOGE,"Could not pass on WNI_CFG_BSSID to CCM\n");

}

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3845

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_BEACON_INTERVAL, pConfig->nBeaconInterval,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3846

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3847

{

3848

fStatus = FALSE;

3849

hddLog(LOGE, "Could not pass on WNI_CFG_BEACON_INTERVAL to CCM\n");

3850

}

3851

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3852

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_PS_POLL, pConfig->nMaxPsPoll,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3853

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3854

{

3855

fStatus = FALSE;

3856

hddLog(LOGE, "Could not pass on WNI_CFG_MAX_PS_POLL to CCM\n");

3857

}

3858

3859

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_CURRENT_RX_ANTENNA, pConfig-> nRxAnt, NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3860

{

3861

fStatus = FALSE;

3862

hddLog(LOGE, "Failure: Could not pass on WNI_CFG_CURRENT_RX_ANTENNA configuration info to HAL\n" );

3863

}

3864

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3865

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_LOW_GAIN_OVERRIDE, pConfig->fIsLowGainOverride,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3866

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3867

{

3868

fStatus = FALSE;

3869

hddLog(LOGE, "Could not pass on WNI_CFG_LOW_GAIN_OVERRIDE to HAL\n");

3870

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3871

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3872

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_RSSI_FILTER_PERIOD, pConfig->nRssiFilterPeriod,

3873

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3874

{

3875

fStatus = FALSE;

3876

hddLog(LOGE, "Could not pass on WNI_CFG_RSSI_FILTER_PERIOD to CCM\n");

3877

}

3878

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3879

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_IGNORE_DTIM, pConfig->fIgnoreDtim,

3880

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3881

{

3882

fStatus = FALSE;

3883

hddLog(LOGE, "Could not pass on WNI_IGNORE_DTIM configuration to CCM\n" );

3884

}

3885

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3886

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_PS_ENABLE_HEART_BEAT, pConfig->fEnableFwHeartBeatMonitoring,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3887

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3888

{

3889

fStatus = FALSE;

3890

hddLog(LOGE, "Failure: Could not pass on WNI_CFG_PS_HEART_BEAT configuration info to CCM\n");

3891

}

3892

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3893

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_PS_ENABLE_BCN_FILTER, pConfig->fEnableFwBeaconFiltering,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3894

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3895

{

3896

fStatus = FALSE;

3897

hddLog(LOGE, "Failure: Could not pass on WNI_CFG_PS_BCN_FILTER configuration info to CCM\n");

3898

}

3899

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3900

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_PS_ENABLE_RSSI_MONITOR, pConfig->fEnableFwRssiMonitoring,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3901

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3902

{

3903

fStatus = FALSE;

3904

hddLog(LOGE, "Failure: Could not pass on WNI_CFG_PS_RSSI_MONITOR configuration info to CCM\n");

3905

}

3906

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3907

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT, pConfig->nDataInactivityTimeout,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3908

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3909

{

3910

fStatus = FALSE;

3911

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT configuration info to CCM\n");

3912

}

3913

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3914

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_NTH_BEACON_FILTER, pConfig->nthBeaconFilter,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3915

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3916

{

3917

fStatus = FALSE;

3918

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_NTH_BEACON_FILTER configuration info to CCM\n");

3919

}

3920

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3921

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LTE_COEX, pConfig->enableLTECoex,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3922

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3923

{

3924

fStatus = FALSE;

3925

hddLog(LOGE, "Could not pass on WNI_CFG_ENABLE_LTE_COEX to CCM\n");

3926

}

3927

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3928

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_PHY_AGC_LISTEN_MODE, pConfig->nEnableListenMode,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3929

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3930

{

3931

fStatus = FALSE;

3932

hddLog(LOGE, "Could not pass on WNI_CFG_ENABLE_PHY_AGC_LISTEN_MODE to CCM\n");

3933

}

3934

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3935

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT, pConfig->apKeepAlivePeriod,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3936

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3937

{

3938

fStatus = FALSE;

3939

hddLog(LOGE, "Could not pass on WNI_CFG_AP_KEEP_ALIVE_TIMEOUT to CCM\n");

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3940

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3941

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3942

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT, pConfig->goKeepAlivePeriod,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3943

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3944

{

3945

fStatus = FALSE;

3946

hddLog(LOGE, "Could not pass on WNI_CFG_GO_KEEP_ALIVE_TIMEOUT to CCM\n");

3947

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3948

Sejal Chauhan

bcde8bc

2013-03-04 18:06:36 +0530

[diff] [blame]

3949

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_AP_LINK_MONITOR_TIMEOUT, pConfig->apLinkMonitorPeriod,

3950

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3951

{

3952

fStatus = FALSE;

3953

hddLog(LOGE, "Could not pass on WNI_CFG_AP_LINK_MONITOR_TIMEOUT to CCM\n");

3954

}

3955

Madan Mohan Koyyalamudi

2558bc9

2013-08-24 16:54:31 +0530

[diff] [blame]

3956

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_GO_LINK_MONITOR_TIMEOUT, pConfig->goLinkMonitorPeriod,

3957

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3958

{

3959

fStatus = FALSE;

3960

hddLog(LOGE, "Could not pass on WNI_CFG_GO_LINK_MONITOR_TIMEOUT to CCM\n");

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3964

#if defined WLAN_FEATURE_VOWIFI

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3965

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_RRM_ENABLED, pConfig->fRrmEnable,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3966

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3967

{

3968

fStatus = FALSE;

3969

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_RRM_ENABLE configuration info to CCM\n");

3970

}

3971

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3972

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_RRM_OPERATING_CHAN_MAX, pConfig->nInChanMeasMaxDuration,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3973

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3974

{

3975

fStatus = FALSE;

3976

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_RRM_OPERATING_CHAN_MAX configuration info to CCM\n");

3977

}

3978

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3979

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_RRM_NON_OPERATING_CHAN_MAX, pConfig->nOutChanMeasMaxDuration,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3980

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3981

{

3982

fStatus = FALSE;

3983

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_RRM_OUT_CHAN_MAX configuration info to CCM\n");

3984

}

3985

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3986

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MCAST_BCAST_FILTER_SETTING, pConfig->mcastBcastFilterSetting,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3987

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3988

#endif

3989

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3990

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SINGLE_TID_RC, pConfig->bSingleTidRc,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3991

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3992

{

3993

fStatus = FALSE;

3994

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_SINGLE_TID_RC configuration info to CCM\n");

3995

}

3996

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3997

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TELE_BCN_WAKEUP_EN, pConfig->teleBcnWakeupEn,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

3998

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3999

{

4000

fStatus = FALSE;

4001

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_TELE_BCN_WAKEUP_EN configuration info to CCM\n" );

4002

}

4003

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4004

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TELE_BCN_TRANS_LI, pConfig->nTeleBcnTransListenInterval,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4005

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4006

{

4007

fStatus = FALSE;

4008

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_TELE_BCN_TRANS_LI configuration info to CCM\n" );

4009

}

4010

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4011

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TELE_BCN_MAX_LI, pConfig->nTeleBcnMaxListenInterval,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4012

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4013

{

4014

fStatus = FALSE;

4015

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_TELE_BCN_MAX_LI configuration info to CCM\n" );

4016

}

4017

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4018

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, pConfig->nTeleBcnTransLiNumIdleBeacons,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4019

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4020

{

4021

fStatus = FALSE;

4022

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS configuration info to CCM\n" );

4023

}

4024

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4025

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, pConfig->nTeleBcnMaxLiNumIdleBeacons,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4026

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4027

{

4028

fStatus = FALSE;

4029

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS configuration info to CCM\n" );

4030

}

4031

4032

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_RF_SETTLING_TIME_CLK, pConfig->rfSettlingTimeUs,

4033

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4034

{

4035

fStatus = FALSE;

4036

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_RF_SETTLING_TIME_CLK configuration info to CCM\n" );

4037

}

4038

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4039

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, pConfig->infraStaKeepAlivePeriod,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4040

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4041

{

4042

fStatus = FALSE;

4043

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD configuration info to CCM\n" );

4044

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4045

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DYNAMIC_PS_POLL_VALUE, pConfig->dynamicPsPollValue,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4046

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4047

{

4048

fStatus = FALSE;

4049

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_DYNAMIC_PS_POLL_VALUE configuration info to CCM\n" );

4050

}

4051

4052

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_PS_NULLDATA_AP_RESP_TIMEOUT, pConfig->nNullDataApRespTimeout,

4053

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4054

{

4055

fStatus = FALSE;

4056

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_PS_NULLDATA_DELAY_TIMEOUT configuration info to CCM\n" );

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4057

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4058

Jeff Johnson

eed2dca

2013-02-22 21:18:46 -0800

[diff] [blame]

4059

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_AP_DATA_AVAIL_POLL_PERIOD, pConfig->apDataAvailPollPeriodInMs,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4060

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

Jeff Johnson

eed2dca

2013-02-22 21:18:46 -0800

[diff] [blame]

4061

{

4062

fStatus = FALSE;

4063

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_AP_DATA_AVAIL_POLL_PERIOD configuration info to CCM\n" );

4064

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4065

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_FRAGMENTATION_THRESHOLD, pConfig->FragmentationThreshold,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4066

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4067

{

4068

fStatus = FALSE;

4069

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_FRAGMENTATION_THRESHOLD configuration info to CCM\n" );

4070

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4071

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_RTS_THRESHOLD, pConfig->RTSThreshold,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4072

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4073

{

4074

fStatus = FALSE;

4075

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_RTS_THRESHOLD configuration info to CCM\n" );

4076

}

4077

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4078

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_11D_ENABLED, pConfig->Is11dSupportEnabled,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4079

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4080

{

4081

fStatus = FALSE;

4082

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_11D_ENABLED configuration info to CCM\n" );

4083

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4084

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HEART_BEAT_THRESHOLD, pConfig->HeartbeatThresh24,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4085

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4086

{

4087

fStatus = FALSE;

4088

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_HEART_BEAT_THRESHOLD configuration info to CCM\n" );

4089

}

4090

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4091

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_AP_DATA_AVAIL_POLL_PERIOD, pConfig->apDataAvailPollPeriodInMs,

4092

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4093

{

4094

fStatus = FALSE;

4095

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_AP_DATA_AVAIL_POLL_PERIOD configuration info to CCM\n" );

4096

}

4097

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4098

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4099

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

4100

==eHAL_STATUS_FAILURE)

4101

{

4102

fStatus = FALSE;

4103

hddLog(LOGE, "Could not pass on WNI_CFG_ENABLE_CLOSE_LOOP to CCM\n");

4104

}

4105

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4106

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4107

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

4108

==eHAL_STATUS_FAILURE)

4109

{

4110

fStatus = FALSE;

4111

hddLog(LOGE, "Could not pass on WNI_CFG_TX_PWR_CTRL_ENABLE to CCM\n");

4112

}

4113

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4114

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4115

pConfig->ShortGI40MhzEnable, NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4116

{

4117

fStatus = FALSE;

4118

hddLog(LOGE, "Could not pass on WNI_CFG_SHORT_GI_40MHZ to CCM\n");

4119

}

4120

Jeff Johnson

d13512a

2012-07-17 11:42:19 -0700

[diff] [blame]

4121

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4122

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_MC_ADDR_LIST, pConfig->fEnableMCAddrList,

Jeff Johnson

d13512a

2012-07-17 11:42:19 -0700

[diff] [blame]

4123

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4124

{

4125

fStatus = FALSE;

4126

hddLog(LOGE, "Could not pass on WNI_CFG_ENABLE_MC_ADDR_LIST to CCM\n");

4127

}

4128

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4129

#ifdef WLAN_FEATURE_11AC

4130

/* Based on cfg.ini, update the Basic MCS set, RX/TX MCS map in the cfg.dat */

4131

/* valid values are 0(MCS0-7), 1(MCS0-8), 2(MCS0-9) */

4132

/* we update only the least significant 2 bits in the corresponding fields */

4133

if( (pConfig->dot11Mode == eHDD_DOT11_MODE_AUTO) ||

4134

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

4135

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

ccmCfgGetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET, &temp);

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4141

temp = (temp & 0xFFFC) | pConfig->vhtRxMCS;

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4142

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4143

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4144

temp, NULL, eANI_BOOLEAN_FALSE)

4145

==eHAL_STATUS_FAILURE)

4146

{

4147

fStatus = FALSE;

4148

hddLog(LOGE, "Could not pass on WNI_CFG_VHT_BASIC_MCS_SET to CCM\n");

4149

}

4150

4151

ccmCfgGetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP, &temp);

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4152

temp = (temp & 0xFFFC) | pConfig->vhtRxMCS;

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4153

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4154

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4155

temp, NULL, eANI_BOOLEAN_FALSE)

4156

==eHAL_STATUS_FAILURE)

4157

{

4158

fStatus = FALSE;

4159

hddLog(LOGE, "Could not pass on WNI_CFG_VHT_RX_MCS_MAP to CCM\n");

4160

}

4161

4162

ccmCfgGetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP, &temp);

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4163

temp = (temp & 0xFFFC) | pConfig->vhtTxMCS;

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4164

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4165

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4166

temp, NULL, eANI_BOOLEAN_FALSE)

4167

==eHAL_STATUS_FAILURE)

4168

{

4169

fStatus = FALSE;

4170

hddLog(LOGE, "Could not pass on WNI_CFG_VHT_TX_MCS_MAP to CCM\n");

}

}

}

#endif

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4176

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_NUM_BUFF_ADVERT,pConfig->numBuffAdvert,

Madan Mohan Koyyalamudi

dd11eaf

2012-11-02 16:04:21 -0700

[diff] [blame]

4177

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4178

{

4179

fStatus = FALSE;

4180

hddLog(LOGE, "Could not pass on WNI_CFG_NUM_BUFF_ADVERT to CCM\n");

4181

}

4182

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4183

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

Pratik Bhalgat

2012-11-22 17:09:40 +0530

[diff] [blame]

4184

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

4185

==eHAL_STATUS_FAILURE)

4186

{

4187

fStatus = FALSE;

4188

hddLog(LOGE, "Could not pass on WNI_CFG_HT_RX_STBC to CCM\n");

4189

}

4190

4191

ccmCfgGetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO, (tANI_U32 *)&htCapInfo);

4192

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

4193

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4194

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

Pratik Bhalgat

2012-11-22 17:09:40 +0530

[diff] [blame]

4195

*(tANI_U32 *)&htCapInfo, NULL, eANI_BOOLEAN_FALSE)

4196

==eHAL_STATUS_FAILURE)

4197

{

4198

fStatus = FALSE;

4199

hddLog(LOGE, "Could not pass on WNI_CFG_HT_CAP_INFO to CCM\n");

4200

}

4201

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4202

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

Pratik Bhalgat

2012-11-22 17:09:40 +0530

[diff] [blame]

4203

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

4204

==eHAL_STATUS_FAILURE)

4205

{

4206

fStatus = FALSE;

4207

hddLog(LOGE, "Could not pass on WNI_CFG_VHT_RXSTBC to CCM\n");

4208

}

Gopichand Nakkala

976e325

2013-01-03 15:45:56 -0800

[diff] [blame]

4209

4210

#ifdef WLAN_SOFTAP_VSTA_FEATURE

4211

if(pConfig->fEnableVSTASupport)

4212

{

4213

ccmCfgGetInt(pHddCtx->hHal, WNI_CFG_ASSOC_STA_LIMIT, &val);

4214

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

4215

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

4220

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4221

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ASSOC_STA_LIMIT, val,

Gopichand Nakkala

976e325

2013-01-03 15:45:56 -0800

[diff] [blame]

4222

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4223

{

4224

fStatus = FALSE;

4225

hddLog(LOGE,"Failure: Could not pass on WNI_CFG_ASSOC_STA_LIMIT configuration info to CCM\n" );

4226

}

4227

#endif

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4228

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

Madan Mohan Koyyalamudi

0d40e66

2012-12-07 14:24:14 -0800

[diff] [blame]

4229

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

4230

==eHAL_STATUS_FAILURE)

4231

{

4232

fStatus = FALSE;

4233

hddLog(LOGE, "Could not pass on WNI_CFG_ENABLE_LPWR_IMG_TRANSITION to CCM\n");

4234

}

Pratik Bhalgat

2012-11-22 17:09:40 +0530

[diff] [blame]

4235

Madan Mohan Koyyalamudi

01cba04

2013-01-10 21:56:05 -0800

[diff] [blame]

4236

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, pConfig->enableMCCAdaptiveScheduler,

4237

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4238

{

4239

fStatus = FALSE;

4240

hddLog(LOGE, "Could not pass on WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED to CCM\n");

4241

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

2013-02-11 00:27:02 -0800

[diff] [blame]

4242

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DISABLE_LDPC_WITH_TXBF_AP, pConfig->disableLDPCWithTxbfAP,

4243

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4244

{

4245

fStatus = FALSE;

Kiran Kumar Lokere

1f39e95

2013-04-03 18:34:30 -0700

[diff] [blame]

4246

hddLog(LOGE, "Could not pass on WNI_CFG_DISABLE_LDPC_WITH_TXBF_AP to CCM");

Leela V Kiran Kumar Reddy Chirala

b1f7d34

2013-02-11 00:27:02 -0800

[diff] [blame]

4247

}

Kiran Kumar Lokere

1f39e95

2013-04-03 18:34:30 -0700

[diff] [blame]

4248

4249

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DYNAMIC_THRESHOLD_ZERO, pConfig->retryLimitZero,

4250

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4251

{

4252

fStatus = FALSE;

4253

hddLog(LOGE, "Could not pass on WNI_CFG_DYNAMIC_THRESHOLD_ZERO to CCM");

4254

}

4255

4256

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DYNAMIC_THRESHOLD_ONE, pConfig->retryLimitOne,

4257

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4258

{

4259

fStatus = FALSE;

4260

hddLog(LOGE, "Could not pass on WNI_CFG_DYNAMIC_THRESHOLD_ONE to CCM");

4261

}

4262

4263

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DYNAMIC_THRESHOLD_TWO, pConfig->retryLimitTwo,

4264

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4265

{

4266

fStatus = FALSE;

4267

hddLog(LOGE, "Could not pass on WNI_CFG_DYNAMIC_THRESHOLD_TWO to CCM");

4268

}

4269

Gopichand Nakkala

42bc89e

2013-05-27 12:49:09 +0530

[diff] [blame]

4270

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_MEDIUM_TIME, pConfig->cfgMaxMediumTime,

4271

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4272

{

4273

fStatus = FALSE;

4274

hddLog(LOGE, "Could not pass on WNI_CFG_MAX_MEDIUM_TIME to CCM");

4275

}

4276

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4277

#ifdef FEATURE_WLAN_TDLS

4278

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4279

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,

4280

pConfig->fTDLSUapsdMask, NULL,

4281

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4282

{

4283

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4284

hddLog(LOGE, "Could not pass on WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK to CCM");

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4285

}

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4286

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_BUF_STA_ENABLED,

4287

pConfig->fEnableTDLSBufferSta, NULL,

4288

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4289

{

4290

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4291

hddLog(LOGE, "Could not pass on WNI_CFG_TDLS_BUF_STA_ENABLED to CCM");

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4292

}

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4293

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_PUAPSD_INACT_TIME,

4294

pConfig->fTDLSPuapsdInactivityTimer, NULL,

4295

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4296

{

4297

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4298

hddLog(LOGE, "Could not pass on WNI_CFG_TDLS_PUAPSD_INACT_TIME to CCM");

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4299

}

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4300

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,

4301

pConfig->fTDLSRxFrameThreshold, NULL,

4302

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4303

{

4304

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4305

hddLog(LOGE, "Could not pass on WNI_CFG_TDLS_RX_FRAME_THRESHOLD to CCM");

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

4306

}

4307

#endif

4308

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

4309

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,

4310

pConfig->fEnableAdaptRxDrain, NULL,

4311

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4312

{

4313

fStatus = FALSE;

4314

hddLog(LOGE, "Could not pass on WNI_CFG_ENABLE_ADAPT_RX_DRAIN to CCM");

4315

}

Yue Ma

0fd2387

2013-08-01 15:56:47 -0700

[diff] [blame]

4316

4317

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_FLEX_CONNECT_POWER_FACTOR,

4318

pConfig->flexConnectPowerFactor, NULL,

4319

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4320

{

4321

fStatus = FALSE;

4322

hddLog(LOGE, "Failure: Could not pass on "

4323

"WNI_CFG_FLEX_CONNECT_POWER_FACTOR to CCM");

4324

}

4325

Madan Mohan Koyyalamudi

ca45457

2013-08-07 19:57:03 +0530

[diff] [blame]

4326

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ANTENNA_DIVESITY,

4327

pConfig->antennaDiversity, NULL,

4328

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4329

{

4330

fStatus = FALSE;

4331

hddLog(LOGE, "Could not pass on WNI_CFG_ANTENNA_DIVESITY to CCM");

4332

}

4333

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

return fStatus;

}

/**---------------------------------------------------------------------------

4339

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4340

\brief hdd_init_set_sme_config() -

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4341

4342

This function initializes the sme configuration parameters

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4343

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4344

\param - pHddCtx - Pointer to the HDD Adapter.

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4345

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4346

\return - 0 for success, non zero for failure

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4347

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4348

--------------------------------------------------------------------------*/

4349

4350

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

4351

{

4352

VOS_STATUS status = VOS_STATUS_SUCCESS;

4353

eHalStatus halStatus;

4354

tSmeConfigParams smeConfig;

4355

4356

hdd_config_t *pConfig = pHddCtx->cfg_ini;

4357

Amar Singhal

fddc28c

2013-09-05 13:03:40 -0700

[diff] [blame]

4358

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4359

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

4360

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4361

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4362

"%s bWmmIsEnabled=%d 802_11e_enabled=%d dot11Mode=%d\n", __func__,

4363

pConfig->WmmMode, pConfig->b80211eIsEnabled, pConfig->dot11Mode);

4364

4365

// Config params obtained from the registry

Amar Singhal

fddc28c

2013-09-05 13:03:40 -0700

[diff] [blame]

4366

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4367

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

4368

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

4369

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

4370

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

4371

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

4372

4373

smeConfig.csrConfig.phyMode = hdd_cfg_xlate_to_csr_phy_mode ( pConfig->dot11Mode );

4374

4375

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

4376

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

4377

smeConfig.csrConfig.TxRate = pConfig->TxRate;

4378

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

4379

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

4380

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

4381

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

4382

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

4383

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

4384

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

4385

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

4386

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

4387

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

4388

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

4389

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

4390

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

4391

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4392

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4393

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

4394

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

4395

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

4396

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4397

smeConfig.csrConfig.nActiveMaxChnTimeBtc = pConfig->nActiveMaxChnTimeBtc;

4398

smeConfig.csrConfig.nActiveMinChnTimeBtc = pConfig->nActiveMinChnTimeBtc;

Kiran Kumar Lokere

458d732

2013-05-29 14:29:43 -0700

[diff] [blame]

4399

smeConfig.csrConfig.disableAggWithBtc = pConfig->disableAggWithBtc;

Madan Mohan Koyyalamudi

4ff9cd6

2012-10-30 17:48:57 -0700

[diff] [blame]

4400

#ifdef WLAN_AP_STA_CONCURRENCY

4401

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

4402

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

4403

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

4404

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

4405

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Sudhir Sattayappa Kohalli

eb97d50

2013-05-22 23:16:42 -0700

[diff] [blame]

4406

smeConfig.csrConfig.nNumStaChanCombinedConc = pConfig->nNumStaChanCombinedConc;

4407

smeConfig.csrConfig.nNumP2PChanCombinedConc = pConfig->nNumP2PChanCombinedConc;

4408

Madan Mohan Koyyalamudi

4ff9cd6

2012-10-30 17:48:57 -0700

[diff] [blame]

4409

#endif

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4410

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

4411

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

4412

4413

#if defined WLAN_FEATURE_VOWIFI

4414

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

4415

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

4416

#endif

4417

//Remaining config params not obtained from registry

4418

// On RF EVB beacon using channel 1.

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4419

#ifdef WLAN_FEATURE_11AC

4420

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

2013-01-17 12:51:24 -0800

[diff] [blame]

4421

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

2013-02-16 18:18:33 -0800

[diff] [blame]

4422

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Ravi Joshi

83bfaa1

2013-05-28 22:12:08 -0700

[diff] [blame]

4423

smeConfig.csrConfig.enableVhtFor24GHz = pConfig->enableVhtFor24GHzBand;

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4424

#endif

Shailender Karmuchi

a734f33

2013-04-19 14:02:48 -0700

[diff] [blame]

4425

smeConfig.csrConfig.AdHocChannel5G = pConfig->AdHocChannel5G;

4426

smeConfig.csrConfig.AdHocChannel24 = pConfig->AdHocChannel24G;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4427

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

4428

smeConfig.csrConfig.HeartbeatThresh50 = 40;

4429

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

2013-01-10 15:24:29 -0800

[diff] [blame]

4430

if (pConfig->nBandCapability == eCSR_BAND_24)

4431

{

4432

smeConfig.csrConfig.Is11hSupportEnabled = 0;

4433

} else {

4434

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

4435

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4436

smeConfig.csrConfig.cbChoice = 0;

4437

smeConfig.csrConfig.bgScanInterval = 0;

4438

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4439

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

4440

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

4441

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

d502607

2012-11-30 14:56:21 -0800

[diff] [blame]

4442

#if defined (WLAN_FEATURE_VOWIFI_11R) || defined (FEATURE_WLAN_CCX) || defined(FEATURE_WLAN_LFR)

4443

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

Srinivas Girigowda

bbd16eb

2013-03-21 12:34:46 -0700

[diff] [blame]

4444

smeConfig.csrConfig.nRoamIntraBand = pConfig->nRoamIntraBand;

Varun Reddy Yeturu

920df21

2013-05-22 08:07:23 -0700

[diff] [blame]

4445

smeConfig.csrConfig.nProbes = pConfig->nProbes;

Srinivas Girigowda

6cf0b82

2013-06-27 14:00:20 -0700

[diff] [blame]

4446

4447

if (pConfig->nRoamScanHomeAwayTime < (pConfig->nNeighborScanMaxChanTime + (2 * HDD_ROAM_SCAN_CHANNEL_SWITCH_TIME)))

4448

{

4449

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,

4450

"%s: Invalid config, Home away time(%d) is less than twice RF switching time + channel max time(%d)"

4451

" Hence enforcing home away time to disable (0)",

4452

__func__, pConfig->nRoamScanHomeAwayTime,

4453

(pConfig->nNeighborScanMaxChanTime + (2 * HDD_ROAM_SCAN_CHANNEL_SWITCH_TIME)));

4454

pConfig->nRoamScanHomeAwayTime = 0;

4455

}

Varun Reddy Yeturu

920df21

2013-05-22 08:07:23 -0700

[diff] [blame]

4456

smeConfig.csrConfig.nRoamScanHomeAwayTime = pConfig->nRoamScanHomeAwayTime;

Madan Mohan Koyyalamudi

d502607

2012-11-30 14:56:21 -0800

[diff] [blame]

4457

#endif

Jeff Johnson

2012-09-05 17:12:55 -0700

[diff] [blame]

4458

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

4459

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4460

//FIXME 11d config is hardcoded

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

4461

if ( VOS_STA_SAP_MODE != hdd_get_conparam())

4462

{

4463

smeConfig.csrConfig.Csr11dinfo.Channels.numChannels = 0;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4464

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

4465

/* if there is a requirement that HDD will control the default

4466

* channel list & country code (say from .ini file) we need to

4467

* add some logic here. Otherwise the default 11d info should

4468

* come from NV as per our current implementation */

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4469

}

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

4470

else

4471

{

4472

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

4473

"AP country Code %s", pConfig->apCntryCode);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4474

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

4475

if (memcmp(pConfig->apCntryCode, CFG_AP_COUNTRY_CODE_DEFAULT, 3) != 0)

4476

sme_setRegInfo(pHddCtx->hHal, pConfig->apCntryCode);

4477

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

4478

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4479

hdd_set_power_save_config(pHddCtx, &smeConfig);

4480

hdd_set_btc_config(pHddCtx);

4481

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4482

#ifdef WLAN_FEATURE_VOWIFI_11R

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4483

smeConfig.csrConfig.csr11rConfig.IsFTResourceReqSupported = pConfig->fFTResourceReqSupported;

4484

#endif

Jeff Johnson

04dd8a8

2012-06-29 20:41:40 -0700

[diff] [blame]

4485

#ifdef FEATURE_WLAN_LFR

4486

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

4487

#endif

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4488

#ifdef FEATURE_WLAN_CCX

4489

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

2012-12-31 14:38:47 -0800

[diff] [blame]

4490

if( pConfig->isCcxIniFeatureEnabled )

4491

{

4492

pConfig->isFastTransitionEnabled = TRUE;

4493

}

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4494

#endif

Jeff Johnson

04dd8a8

2012-06-29 20:41:40 -0700

[diff] [blame]

4495

#if defined (WLAN_FEATURE_VOWIFI_11R) || defined (FEATURE_WLAN_CCX) || defined(FEATURE_WLAN_LFR)

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4496

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

2012-07-17 12:26:56 -0700

[diff] [blame]

4497

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

2012-12-03 16:45:39 -0800

[diff] [blame]

4498

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Srinivas Girigowda

ad34ca9

2013-10-22 10:54:29 -0700

[diff] [blame^]

4499

smeConfig.csrConfig.isWESModeEnabled = pConfig->isWESModeEnabled;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4500

#endif

Varun Reddy Yeturu

d0a3f25

2013-04-15 21:58:13 -0700

[diff] [blame]

4501

#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD

4502

smeConfig.csrConfig.isRoamOffloadScanEnabled = pConfig->isRoamOffloadScanEnabled;

Srinivas Girigowda

830bbd0

2013-06-13 19:44:16 -0700

[diff] [blame]

4503

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = pConfig->bFastRoamInConIniFeatureEnabled;

4504

4505

if (0 == smeConfig.csrConfig.isRoamOffloadScanEnabled)

4506

{

4507

/* Disable roaming in concurrency if roam scan offload is disabled */

4508

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = 0;

4509

}

Varun Reddy Yeturu

d0a3f25

2013-04-15 21:58:13 -0700

[diff] [blame]

4510

#endif

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4511

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

4512

smeConfig.csrConfig.neighborRoamConfig.nNeighborReassocRssiThreshold = pConfig->nNeighborReassocRssiThreshold;

4513

smeConfig.csrConfig.neighborRoamConfig.nNeighborLookupRssiThreshold = pConfig->nNeighborLookupRssiThreshold;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4514

smeConfig.csrConfig.neighborRoamConfig.nNeighborScanMaxChanTime = pConfig->nNeighborScanMaxChanTime;

4515

smeConfig.csrConfig.neighborRoamConfig.nNeighborScanMinChanTime = pConfig->nNeighborScanMinChanTime;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4516

smeConfig.csrConfig.neighborRoamConfig.nNeighborScanTimerPeriod = pConfig->nNeighborScanPeriod;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4517

smeConfig.csrConfig.neighborRoamConfig.nMaxNeighborRetries = pConfig->nMaxNeighborReqTries;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4518

smeConfig.csrConfig.neighborRoamConfig.nNeighborResultsRefreshPeriod = pConfig->nNeighborResultsRefreshPeriod;

Srinivas Girigowda

de69741

2013-02-14 16:31:48 -0800

[diff] [blame]

4519

smeConfig.csrConfig.neighborRoamConfig.nEmptyScanRefreshPeriod = pConfig->nEmptyScanRefreshPeriod;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4520

hdd_string_to_u8_array( pConfig->neighborScanChanList,

4521

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

4522

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4523

WNI_CFG_VALID_CHANNEL_LIST_LEN );

4524

#endif

4525

4526

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

4527

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

4528

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4529

//Enable/Disable MCC

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4530

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

2012-09-11 17:52:10 -0700

[diff] [blame]

4531

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4532

Sandeep Puligilla

2b6dc63

2012-12-17 14:44:16 -0800

[diff] [blame]

4533

//Scan Results Aging Time out value

4534

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

4535

Gopichand Nakkala

b2d2c31

2013-01-04 11:41:02 -0800

[diff] [blame]

4536

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

4537

krunal soni

5afa96c

2013-09-06 22:19:02 -0700

[diff] [blame]

4538

smeConfig.csrConfig.isAmsduSupportInAMPDU = pConfig->isAmsduSupportInAMPDU;

4539

Gopichand Nakkala

2013-04-26 05:45:57 -0700

[diff] [blame]

4540

/* update SSR config */

4541

sme_UpdateEnableSSR((tHalHandle)(pHddCtx->hHal), pHddCtx->cfg_ini->enableSSR);

Gopichand Nakkala

86e4266

2013-06-11 17:44:11 +0530

[diff] [blame]

4542

/* Update the Directed scan offload setting */

4543

smeConfig.fScanOffload = pHddCtx->cfg_ini->fScanOffload;

Gopichand Nakkala

2013-04-26 05:45:57 -0700

[diff] [blame]

4544

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4545

halStatus = sme_UpdateConfig( pHddCtx->hHal, &smeConfig);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4546

if ( !HAL_STATUS_SUCCESS( halStatus ) )

4547

{

4548

status = VOS_STATUS_E_FAILURE;

4549

}

4550

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

4551

4552

return status;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

}

/**---------------------------------------------------------------------------

4557

4558

\brief hdd_execute_config_command() -

4559

4560

This function executes an arbitrary configuration set command

4561

4562

\param - pHddCtx - Pointer to the HDD Adapter.

4563

\parmm - command - a configuration command of the form:

4564

4565

4566

\return - 0 for success, non zero for failure

4567

4568

--------------------------------------------------------------------------*/

4569

4570

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

4571

{

4572

size_t tableSize = sizeof(g_registry_table)/sizeof(g_registry_table[0]);

4573

REG_TABLE_ENTRY *pRegEntry;

char *clone;

char *pCmd;

void *pField;

char *name;

char *value_str;

v_U32_t value;

v_S31_t svalue;

size_t len_value_str;

4582

unsigned int idx;

4583

unsigned int i;

4584

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

4585

int rv;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4586

4587

// assume failure until proven otherwise

4588

vstatus = VOS_STATUS_E_FAILURE;

4589

4590

// clone the command so that we can manipulate it

4591

clone = kstrdup(command, GFP_ATOMIC);

4592

if (NULL == clone)

4593

{

4594

hddLog(LOGE, "%s: memory allocation failure, unable to process [%s]",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4595

__func__, command);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

return vstatus;

}

// 'clone' will point to the beginning of the string so it can be freed

4600

// 'pCmd' will be used to walk/parse the command

4601

pCmd = clone;

4602

4603

// get rid of leading/trailing whitespace

pCmd = i_trim(pCmd);

if ('\0' == *pCmd)

{

// only whitespace

hddLog(LOGE, "%s: invalid command, only whitespace:[%s]",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4609

__func__, command);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

goto done;

}

// parse the <name> = <value>

4614

name = pCmd;

4615

while (('=' != *pCmd) && ('\0' != *pCmd))

{

pCmd++;

}

if ('\0' == *pCmd)

{

// did not find '='

hddLog(LOGE, "%s: invalid command, no '=':[%s]",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4623

__func__, command);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

goto done;

}

// replace '=' with NUL to terminate the <name>

*pCmd++ = '\0';

name = i_trim(name);

if ('\0' == *name)

{

// did not find a name

4633

hddLog(LOGE, "%s: invalid command, no <name>:[%s]",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4634

__func__, command);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

4639

if ('\0' == *value_str)

4640

{

4641

// did not find a value

4642

hddLog(LOGE, "%s: invalid command, no <value>:[%s]",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4643

__func__, command);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

goto done;

}

// lookup the configuration item

4648

for (idx = 0; idx < tableSize; idx++)

4649

{

4650

if (0 == strcmp(name, g_registry_table[idx].RegName))

{

// found a match

break;

}

}

if (tableSize == idx)

4657

{

4658

// did not match the name

4659

hddLog(LOGE, "%s: invalid command, unknown configuration item:[%s]",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4660

__func__, command);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

4665

if (!(pRegEntry->Flags & VAR_FLAGS_DYNAMIC_CFG))

4666

{

4667

// does not support dynamic configuration

4668

hddLog(LOGE, "%s: invalid command, %s does not support "

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4669

"dynamic configuration", __func__, name);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

goto done;

}

pField = ((v_U8_t *)pHddCtx->cfg_ini) + pRegEntry->VarOffset;

4674

4675

switch (pRegEntry->RegType)

4676

{

4677

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

4678

rv = kstrtoul(value_str, 10, &value);

4679

if (rv < 0)

4680

goto done;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4681

if (value < pRegEntry->VarMin)

4682

{

4683

// out of range

4684

hddLog(LOGE, "%s: invalid command, value %u < min value %u",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4685

__func__, value, pRegEntry->VarMin);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4686

goto done;

4687

}

4688

if (value > pRegEntry->VarMax)

4689

{

4690

// out of range

4691

hddLog(LOGE, "%s: invalid command, value %u > max value %u",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4692

__func__, value, pRegEntry->VarMax);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4693

goto done;

4694

}

4695

memcpy(pField, &value, pRegEntry->VarSize);

4696

break;

4697

4698

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

4699

rv = kstrtoul(value_str, 16, &value);

4700

if (rv < 0)

4701

goto done;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4702

if (value < pRegEntry->VarMin)

4703

{

4704

// out of range

4705

hddLog(LOGE, "%s: invalid command, value %x < min value %x",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4706

__func__, value, pRegEntry->VarMin);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4707

goto done;

4708

}

4709

if (value > pRegEntry->VarMax)

4710

{

4711

// out of range

4712

hddLog(LOGE, "%s: invalid command, value %x > max value %x",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4713

__func__, value, pRegEntry->VarMax);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4714

goto done;

4715

}

4716

memcpy(pField, &value, pRegEntry->VarSize);

4717

break;

4718

4719

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

2012-11-06 19:04:56 -0800

[diff] [blame]

4720

rv = kstrtol(value_str, 10, &svalue);

4721

if (rv < 0)

4722

goto done;

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4723

if (svalue < (v_S31_t)pRegEntry->VarMin)

4724

{

4725

// out of range

4726

hddLog(LOGE, "%s: invalid command, value %d < min value %d",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4727

__func__, svalue, (int)pRegEntry->VarMin);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4728

goto done;

4729

}

4730

if (svalue > (v_S31_t)pRegEntry->VarMax)

4731

{

4732

// out of range

4733

hddLog(LOGE, "%s: invalid command, value %d > max value %d",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4734

__func__, svalue, (int)pRegEntry->VarMax);

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4735

goto done;

4736

}

4737

memcpy(pField, &svalue, pRegEntry->VarSize);

4738

break;

4739

4740

case WLAN_PARAM_String:

4741

len_value_str = strlen(value_str);

4742

if (len_value_str > (pRegEntry->VarSize - 1))

{

// too big

hddLog(LOGE,

"%s: invalid command, string [%s] length "

4747

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4748

__func__, value_str,

Jeff Johnson

2012-06-20 16:38:30 -0700

[diff] [blame]

4749

len_value_str, (pRegEntry->VarSize - 1));

4750

goto done;

4751

}

4752

// copy string plus NUL

4753

memcpy(pField, value_str, (len_value_str + 1));

4754

break;

4755

4756

case WLAN_PARAM_MacAddr:

4757

len_value_str = strlen(value_str);

4758

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

"%s: invalid command, MAC address [%s] length "

4763

"%u is not expected length %u",

Madan Mohan Koyyalamudi

2012-11-02 13:24:12 -0700

[diff] [blame]

4764

__func__, value_str,

Jeff Johnson