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

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

[diff] [blame]

3079

#endif

3080

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

3081

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

3082

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

3083

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

3084

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

3085

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

3086

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

3087

3088

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

3089

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

3090

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

3091

#ifdef WLAN_BTAMP_FEATURE

3092

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

3093

#endif //WLAN_BTAMP_FEATURE

3094

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

3095

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

3096

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

3097

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

3098

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

3099

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

3100

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

3101

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

3102

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

3103

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

3104

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

3105

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

3106

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]

3107

#ifdef WLAN_FEATURE_11AC

3108

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

3109

#endif

3110

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

3111

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

3112

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]

3113

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]

3114

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]

3115

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]

3116

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]

3117

Leo Chang

64d68bc

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

[diff] [blame]

3118

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

3119

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]

3120

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]

3121

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]

3122

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]

3123

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

3124

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

3125

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

3126

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

3127

Jeff Johnson

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

[diff] [blame]

}

Gopichand Nakkala

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

[diff] [blame]

3131

Jeff Johnson

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

[diff] [blame]

3132

#define CFG_VALUE_MAX_LEN 256

3133

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

3134

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

3135

{

3136

unsigned int idx;

3137

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

3138

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

3139

v_U32_t value;

3140

char valueStr[CFG_VALUE_MAX_LEN];

3141

char configStr[CFG_ENTRY_MAX_LEN];

3142

char *fmt;

3143

void *pField;

3144

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

3149

*pCur = '\0';

3150

Kiran Kumar Lokere

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

[diff] [blame]

3151

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

Jeff Johnson

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

[diff] [blame]

3152

{

3153

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

3154

3155

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

3156

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

Kiran Kumar Lokere

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

[diff] [blame]

3157

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

Jeff Johnson

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

[diff] [blame]

3158

{

3159

value = 0;

3160

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

3161

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);

3174

}

3175

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3176

{

3177

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

3178

}

3179

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3180

{

3181

pMacAddr = (v_MACADDR_t *) pField;

3182

snprintf(valueStr, CFG_VALUE_MAX_LEN,

3183

"%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)");

3194

}

3195

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

3200

"*" : "");

3201

3202

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

3203

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

3204

#ifdef RETURN_IN_BUFFER

3205

if (curlen <= buflen)

3206

{

3207

// copy string + '\0'

3208

memcpy(pCur, configStr, curlen+1);

3209

3210

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

3217

return VOS_STATUS_E_RESOURCES;

3218

}

3219

#else

3220

printk(KERN_CRIT "%s", configStr);

3221

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

3226

// notify application that output is in system log

3227

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

3228

#endif // RETURN_IN_BUFFER

3229

3230

return VOS_STATUS_SUCCESS;

3231

}

3232

3233

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

Kiran Kumar Lokere

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

[diff] [blame]

3234

char *name, char** value)

Jeff Johnson

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

[diff] [blame]

3235

{

3236

VOS_STATUS status = VOS_STATUS_E_FAILURE;

3237

unsigned long i;

3238

3239

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

3240

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

3241

*value = iniTable[i].value;

3242

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

3243

WLAN_INI_FILE, name, *value);

3244

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

3252

{

3253

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

3254

return c-'0';

3255

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

3256

return c-'a'+10;

3257

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)

3265

{

3266

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

3267

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

3268

unsigned int idx;

3269

void *pField;

3270

char *value_str = NULL;

3271

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

3276

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

3277

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

3278

v_U32_t cbOutString;

3279

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3280

int rv;

Jeff Johnson

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

[diff] [blame]

3281

3282

// sanity test

3283

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

3284

{

3285

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]

3286

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

3287

}

3288

3289

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

3290

{

3291

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

3292

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

3293

3294

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

3295

3296

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

3297

{

3298

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

3299

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3300

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3301

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

3306

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

3307

{

3308

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

3309

// If not, use the default value.

3310

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3311

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

3312

if (rv < 0) {

3313

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

3314

__func__, pRegEntry->RegName);

3315

value = pRegEntry->VarDefault;

3316

}

Jeff Johnson

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

[diff] [blame]

3317

}

3318

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3319

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

3320

if (rv < 0) {

3321

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

3322

__func__, pRegEntry->RegName);

3323

value = pRegEntry->VarDefault;

3324

}

Jeff Johnson

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

[diff] [blame]

3325

}

3326

else {

3327

value = pRegEntry->VarDefault;

3328

}

3329

3330

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

3331

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

3332

{

3333

if ( value > pRegEntry->VarMax )

3334

{

3335

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3336

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

Jeff Johnson

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

[diff] [blame]

3337

value = pRegEntry->VarMax;

3338

}

3339

3340

if ( value < pRegEntry->VarMin )

3341

{

3342

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3343

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

Jeff Johnson

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

[diff] [blame]

3344

value = pRegEntry->VarMin;

3345

}

3346

}

3347

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

3348

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3349

{

3350

if ( value > pRegEntry->VarMax )

3351

{

3352

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]

3353

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

Jeff Johnson

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

[diff] [blame]

3354

value = pRegEntry->VarDefault;

3355

}

3356

3357

if ( value < pRegEntry->VarMin )

3358

{

3359

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]

3360

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

Jeff Johnson

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

[diff] [blame]

3361

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3366

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

3367

}

3368

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

3369

{

3370

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

3371

// If not, use the default value.

3372

if (VOS_STATUS_SUCCESS == match_status)

3373

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

3374

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

3375

if (rv < 0) {

3376

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

3377

__func__, pRegEntry->RegName);

3378

svalue = (v_S31_t)pRegEntry->VarDefault;

3379

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

3384

}

3385

3386

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

3387

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

3388

{

3389

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

3390

{

3391

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3392

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

Jeff Johnson

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

[diff] [blame]

3393

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

3394

svalue = (v_S31_t)pRegEntry->VarMax;

3395

}

3396

3397

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

3398

{

3399

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3400

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

Jeff Johnson

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

[diff] [blame]

3401

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

3402

svalue = (v_S31_t)pRegEntry->VarMin;

3403

}

3404

}

3405

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

3406

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3407

{

3408

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

3409

{

3410

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

3411

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3412

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3413

(int)pRegEntry->VarMax,

3414

(int)pRegEntry->VarDefault );

3415

svalue = (v_S31_t)pRegEntry->VarDefault;

3416

}

3417

3418

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

3419

{

3420

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

3421

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3422

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3423

(int)pRegEntry->VarMin,

3424

(int)pRegEntry->VarDefault);

3425

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3430

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

3431

}

3432

// Handle string parameters

3433

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3434

{

3435

#ifdef WLAN_CFG_DEBUG

3436

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]

3437

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

Jeff Johnson

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

[diff] [blame]

3438

#endif

3439

Kiran Kumar Lokere

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

[diff] [blame]

3440

if ( match_status == VOS_STATUS_SUCCESS)

Jeff Johnson

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

[diff] [blame]

3441

{

3442

len_value_str = strlen(value_str);

3443

3444

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

Kiran Kumar Lokere

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

[diff] [blame]

3445

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]

3446

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

Jeff Johnson

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

[diff] [blame]

3447

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

3448

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

3449

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

}

else

{

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

3454

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

3455

}

3456

}

Kiran Kumar Lokere

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

[diff] [blame]

3457

else

Jeff Johnson

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

[diff] [blame]

3458

{

3459

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

3460

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

3461

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

Kiran Kumar Lokere

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

[diff] [blame]

3462

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

Jeff Johnson

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

[diff] [blame]

3463

}

3464

}

3465

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3466

{

3467

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

Kiran Kumar Lokere

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

[diff] [blame]

3468

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

3469

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

Jeff Johnson

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

[diff] [blame]

3470

continue;

3471

}

3472

candidate = (char*)pRegEntry->VarDefault;

3473

if ( match_status == VOS_STATUS_SUCCESS) {

3474

len_value_str = strlen(value_str);

3475

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

Kiran Kumar Lokere

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

[diff] [blame]

3476

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]

3477

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

Jeff Johnson

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

[diff] [blame]

3478

}

3479

else

3480

candidate = value_str;

3481

}

3482

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

3483

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

3484

{

Kiran Kumar Lokere

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

[diff] [blame]

3485

((char*)pField)[i] =

3486

(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]

3491

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]

3492

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3493

}

3494

3495

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

3496

if( (match_status == VOS_STATUS_SUCCESS) &&

3497

(idx < MAX_CFG_INI_ITEMS) )

3498

{

3499

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

}

}

print_hdd_cfg(pHddCtx);

3504

3505

return( ret_status );

3506

}

3507

3508

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

3509

{

Kiran Kumar Lokere

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

[diff] [blame]

3510

switch (dot11Mode)

Jeff Johnson

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

[diff] [blame]

3511

{

3512

case (eHDD_DOT11_MODE_abg):

3513

return eCSR_DOT11_MODE_abg;

3514

case (eHDD_DOT11_MODE_11b):

3515

return eCSR_DOT11_MODE_11b;

3516

case (eHDD_DOT11_MODE_11g):

3517

return eCSR_DOT11_MODE_11g;

3518

default:

3519

case (eHDD_DOT11_MODE_11n):

3520

return eCSR_DOT11_MODE_11n;

3521

case (eHDD_DOT11_MODE_11g_ONLY):

3522

return eCSR_DOT11_MODE_11g_ONLY;

3523

case (eHDD_DOT11_MODE_11n_ONLY):

3524

return eCSR_DOT11_MODE_11n_ONLY;

3525

case (eHDD_DOT11_MODE_11b_ONLY):

3526

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

3527

#ifdef WLAN_FEATURE_11AC

3528

case (eHDD_DOT11_MODE_11ac_ONLY):

3529

return eCSR_DOT11_MODE_11ac_ONLY;

3530

case (eHDD_DOT11_MODE_11ac):

3531

return eCSR_DOT11_MODE_11ac;

3532

#endif

Jeff Johnson

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

[diff] [blame]

3533

case (eHDD_DOT11_MODE_AUTO):

3534

return eCSR_DOT11_MODE_AUTO;

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3539

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

Jeff Johnson

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

[diff] [blame]

3540

{

3541

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3542

tSmeBtcConfig btcParams;

Wilson Tsao

f8b3794

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

[diff] [blame]

3543

int i;

Kiran Kumar Lokere

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

[diff] [blame]

3544

Jeff Johnson

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

[diff] [blame]

3545

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

3546

3547

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

3548

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

3549

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

3550

Jeff Johnson

32d95a3

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

[diff] [blame]

3551

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

3552

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

3553

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

3554

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

3555

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

3556

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

3557

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

3558

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

3559

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

3560

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

3561

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

3562

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

3563

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

3564

Wilson Tsao

f8b3794

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

[diff] [blame]

3565

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

3566

{

3567

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

3568

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

3569

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

3570

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

3571

}

3572

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

3573

{

3574

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

3575

}

3576

btcParams.mwsCoexModemBackoff = pConfig->mwsCoexModemBackoff;

3577

btcParams.SARPowerBackoff = pConfig->SARPowerBackoff;

3578

Jeff Johnson

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

[diff] [blame]

3579

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

3580

}

3581

Kiran Kumar Lokere

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

[diff] [blame]

3582

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

Jeff Johnson

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

[diff] [blame]

3583

{

3584

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3585

3586

tPmcBmpsConfigParams bmpsParams;

Kiran Kumar Lokere

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

[diff] [blame]

3587

Jeff Johnson

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

[diff] [blame]

3588

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

Kiran Kumar Lokere

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

[diff] [blame]

3589

Jeff Johnson

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

[diff] [blame]

3590

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

3591

{

3592

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

3593

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

3594

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3595

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3596

}

3597

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

3598

{

3599

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

3600

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

3601

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3602

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3603

}

3604

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

3605

{

3606

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

3607

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

3608

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3609

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3610

}

3611

3612

if (pConfig->fIsImpsEnabled)

3613

{

3614

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

3619

}

3620

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

3621

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

3622

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

3623

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

3624

Jeff Johnson

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

[diff] [blame]

3625

if (pConfig->fIsBmpsEnabled)

3626

{

3627

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

3632

}

3633

3634

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

3635

3636

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

3637

{

3638

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

3639

}

Kiran Kumar Lokere

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

[diff] [blame]

3640

Jeff Johnson

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

[diff] [blame]

3641

if(pConfig->fIsAutoBmpsTimerEnabled)

3642

{

3643

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3649

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 )

3654

{

3655

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

3659

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

3660

{

3661

int val;

3662

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

3663

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

3664

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

3665

{

3666

intArray[*len] = (tANI_U8) val;

3667

*len += 1;

3668

}

3669

s = strpbrk( s, "," );

3670

if( s )

3671

s++;

3672

}

Jeff Johnson

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

[diff] [blame]

3673

3674

return VOS_STATUS_SUCCESS;

Kiran Kumar Lokere

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

[diff] [blame]

3675

Jeff Johnson

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

[diff] [blame]

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

3681

{

3682

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

3683

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3684

tANI_U32 val;

3685

#endif

Jeff Johnson

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

[diff] [blame]

3686

3687

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

3688

tSirMacHTCapabilityInfo htCapInfo;

3689

Jeff Johnson

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

[diff] [blame]

3690

Kiran Kumar Lokere

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

[diff] [blame]

3691

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

Jeff Johnson

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

[diff] [blame]

3692

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

3693

{

3694

fStatus = FALSE;

3695

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

3696

}

Kiran Kumar Lokere

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

[diff] [blame]

3697

3698

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

Jeff Johnson

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

[diff] [blame]

3699

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3700

{

3701

fStatus = FALSE;

3702

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

3703

}

3704

3705

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

3706

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3707

{

3708

fStatus = FALSE;

3709

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

3710

}

3711

3712

if ( 0 != pConfig->Cfg1Id )

3713

{

Kiran Kumar Lokere

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

[diff] [blame]

3714

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

Jeff Johnson

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

[diff] [blame]

3715

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3716

{

3717

fStatus = FALSE;

3718

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

3719

}

Kiran Kumar Lokere

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

[diff] [blame]

3720

Jeff Johnson

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

[diff] [blame]

3721

}

3722

3723

if ( 0 != pConfig->Cfg2Id )

3724

{

Kiran Kumar Lokere

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

[diff] [blame]

3725

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

Jeff Johnson

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

[diff] [blame]

3726

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3727

{

3728

fStatus = FALSE;

3729

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

}

}

if ( 0 != pConfig->Cfg3Id )

3734

{

Kiran Kumar Lokere

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

[diff] [blame]

3735

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

Jeff Johnson

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

[diff] [blame]

3736

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3737

{

3738

fStatus = FALSE;

3739

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

}

}

if ( 0 != pConfig->Cfg4Id )

3744

{

Kiran Kumar Lokere

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

[diff] [blame]

3745

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

Jeff Johnson

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

[diff] [blame]

3746

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3747

{

3748

fStatus = FALSE;

3749

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

}

}

if ( 0 != pConfig->Cfg5Id )

3754

{

Kiran Kumar Lokere

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

[diff] [blame]

3755

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

Jeff Johnson

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

[diff] [blame]

3756

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3757

{

3758

fStatus = FALSE;

3759

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

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3763

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

Jeff Johnson

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

[diff] [blame]

3764

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3765

{

3766

fStatus = FALSE;

3767

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

3768

}

Kiran Kumar Lokere

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

[diff] [blame]

3769

3770

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

Jeff Johnson

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

[diff] [blame]

3771

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3772

{

3773

fStatus = FALSE;

3774

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

3775

}

3776

Kiran Kumar Lokere

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

[diff] [blame]

3777

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

Jeff Johnson

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

[diff] [blame]

3778

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

3779

{

3780

fStatus = FALSE;

3781

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

3782

}

3783

3784

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

3785

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3786

{

3787

fStatus = FALSE;

3788

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

3789

}

3790

Kiran Kumar Lokere

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

[diff] [blame]

3791

if (pConfig->fIsAutoIbssBssid)

Jeff Johnson

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

[diff] [blame]

3792

{

Kiran Kumar Lokere

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

[diff] [blame]

3793

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

Jeff Johnson

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

[diff] [blame]

3794

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

3795

{

3796

fStatus = FALSE;

3797

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

3798

}

3799

}

3800

else

Kiran Kumar Lokere

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

[diff] [blame]

3801

{

Jeff Johnson

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

[diff] [blame]

3802

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

3803

{

3804

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3805

"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]

3806

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

Jeff Johnson

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

[diff] [blame]

3807

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

Kiran Kumar Lokere

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

[diff] [blame]

3808

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

Jeff Johnson

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

[diff] [blame]

3809

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

3810

{

3811

fStatus = FALSE;

3812

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]

3822

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

Jeff Johnson

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

[diff] [blame]

3823

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3824

{

3825

fStatus = FALSE;

3826

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

3827

}

3828

Kiran Kumar Lokere

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

[diff] [blame]

3829

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

Jeff Johnson

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

[diff] [blame]

3830

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3831

{

3832

fStatus = FALSE;

3833

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

3834

}

3835

3836

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

3837

{

3838

fStatus = FALSE;

3839

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

3840

}

3841

Kiran Kumar Lokere

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

[diff] [blame]

3842

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

Jeff Johnson

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

[diff] [blame]

3843

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3844

{

3845

fStatus = FALSE;

3846

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

3847

}

Kiran Kumar Lokere

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

[diff] [blame]

3848

Jeff Johnson

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

[diff] [blame]

3849

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

3850

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3851

{

3852

fStatus = FALSE;

3853

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

3854

}

3855

Jeff Johnson

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

[diff] [blame]

3856

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

3857

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3858

{

3859

fStatus = FALSE;

3860

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

3861

}

3862

Kiran Kumar Lokere

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

[diff] [blame]

3863

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

Jeff Johnson

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

[diff] [blame]

3864

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3865

{

3866

fStatus = FALSE;

3867

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

3868

}

3869

Kiran Kumar Lokere

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

[diff] [blame]

3870

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

Jeff Johnson

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

[diff] [blame]

3871

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3872

{

3873

fStatus = FALSE;

3874

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

3875

}

3876

Kiran Kumar Lokere

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

[diff] [blame]

3877

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

Jeff Johnson

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

[diff] [blame]

3878

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3879

{

3880

fStatus = FALSE;

3881

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

3882

}

3883

Kiran Kumar Lokere

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

[diff] [blame]

3884

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

Jeff Johnson

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

[diff] [blame]

3885

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3886

{

3887

fStatus = FALSE;

3888

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

3889

}

3890

Kiran Kumar Lokere

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

[diff] [blame]

3891

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

Jeff Johnson

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

[diff] [blame]

3892

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3893

{

3894

fStatus = FALSE;

3895

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

3896

}

3897

Kiran Kumar Lokere

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

[diff] [blame]

3898

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

Jeff Johnson

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

[diff] [blame]

3899

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3900

{

3901

fStatus = FALSE;

3902

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

3903

}

3904

Kiran Kumar Lokere

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

[diff] [blame]

3905

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

Jeff Johnson

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

[diff] [blame]

3906

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3907

{

3908

fStatus = FALSE;

3909

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

3910

}

3911

Kiran Kumar Lokere

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

[diff] [blame]

3912

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

Jeff Johnson

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

[diff] [blame]

3913

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3914

{

3915

fStatus = FALSE;

3916

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]

3917

}

Jeff Johnson

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

[diff] [blame]

3918

Kiran Kumar Lokere

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

[diff] [blame]

3919

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

Jeff Johnson

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

[diff] [blame]

3920

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3921

{

3922

fStatus = FALSE;

3923

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

3924

}

Kiran Kumar Lokere

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

[diff] [blame]

3925

Sejal Chauhan

bcde8bc

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

[diff] [blame]

3926

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

3927

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3928

{

3929

fStatus = FALSE;

3930

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

3931

}

3932

Madan Mohan Koyyalamudi

2558bc9

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

[diff] [blame]

3933

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

3934

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3935

{

3936

fStatus = FALSE;

3937

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]

3941

#if defined WLAN_FEATURE_VOWIFI

Kiran Kumar Lokere

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

[diff] [blame]

3942

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

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,"Failure: Could not pass on WNI_CFG_RRM_ENABLE configuration info to CCM\n");

3947

}

3948

Kiran Kumar Lokere

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

[diff] [blame]

3949

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

Jeff Johnson

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

[diff] [blame]

3950

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3951

{

3952

fStatus = FALSE;

3953

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

3954

}

3955

Kiran Kumar Lokere

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

[diff] [blame]

3956

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

Jeff Johnson

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

[diff] [blame]

3957

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3958

{

3959

fStatus = FALSE;

3960

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

3961

}

3962

Kiran Kumar Lokere

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

[diff] [blame]

3963

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

Jeff Johnson

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

[diff] [blame]

3964

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3965

#endif

3966

Kiran Kumar Lokere

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

[diff] [blame]

3967

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

Jeff Johnson

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

[diff] [blame]

3968

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3969

{

3970

fStatus = FALSE;

3971

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

3972

}

3973

Kiran Kumar Lokere

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

[diff] [blame]

3974

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

Jeff Johnson

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

[diff] [blame]

3975

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3976

{

3977

fStatus = FALSE;

3978

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

3979

}

3980

Kiran Kumar Lokere

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

[diff] [blame]

3981

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

Jeff Johnson

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

[diff] [blame]

3982

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3983

{

3984

fStatus = FALSE;

3985

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

3986

}

3987

Kiran Kumar Lokere

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

[diff] [blame]

3988

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

Jeff Johnson

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

[diff] [blame]

3989

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3990

{

3991

fStatus = FALSE;

3992

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

3993

}

3994

Kiran Kumar Lokere

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

[diff] [blame]

3995

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]

3996

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3997

{

3998

fStatus = FALSE;

3999

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

4000

}

4001

Kiran Kumar Lokere

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

[diff] [blame]

4002

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]

4003

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4004

{

4005

fStatus = FALSE;

4006

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

4007

}

4008

4009

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

4010

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4011

{

4012

fStatus = FALSE;

4013

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

4014

}

4015

Kiran Kumar Lokere

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

[diff] [blame]

4016

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

Jeff Johnson

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

[diff] [blame]

4017

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4018

{

4019

fStatus = FALSE;

4020

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

4021

}

Kiran Kumar Lokere

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

[diff] [blame]

4022

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

Jeff Johnson

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

[diff] [blame]

4023

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4024

{

4025

fStatus = FALSE;

4026

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

4027

}

4028

4029

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

4030

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4031

{

4032

fStatus = FALSE;

4033

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]

4034

}

Jeff Johnson

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

[diff] [blame]

4035

Jeff Johnson

eed2dca

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

[diff] [blame]

4036

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

Jeff Johnson

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

[diff] [blame]

4037

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

Jeff Johnson

eed2dca

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

[diff] [blame]

4038

{

4039

fStatus = FALSE;

4040

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

4041

}

Kiran Kumar Lokere

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

[diff] [blame]

4042

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

Jeff Johnson

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

[diff] [blame]

4043

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4044

{

4045

fStatus = FALSE;

4046

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

4047

}

Kiran Kumar Lokere

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

[diff] [blame]

4048

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

Jeff Johnson

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

[diff] [blame]

4049

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4050

{

4051

fStatus = FALSE;

4052

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

4053

}

4054

Kiran Kumar Lokere

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

[diff] [blame]

4055

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

Jeff Johnson

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

[diff] [blame]

4056

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4057

{

4058

fStatus = FALSE;

4059

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

4060

}

Kiran Kumar Lokere

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

[diff] [blame]

4061

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

Jeff Johnson

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

[diff] [blame]

4062

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4063

{

4064

fStatus = FALSE;

4065

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

4066

}

4067

Jeff Johnson

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

[diff] [blame]

4068

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

4069

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4070

{

4071

fStatus = FALSE;

4072

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

4073

}

4074

Kiran Kumar Lokere

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

[diff] [blame]

4075

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

Jeff Johnson

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

[diff] [blame]

4076

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

4077

==eHAL_STATUS_FAILURE)

4078

{

4079

fStatus = FALSE;

4080

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

4081

}

4082

Kiran Kumar Lokere

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

[diff] [blame]

4083

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

Jeff Johnson

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

[diff] [blame]

4084

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

4085

==eHAL_STATUS_FAILURE)

4086

{

4087

fStatus = FALSE;

4088

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

4089

}

4090

Kiran Kumar Lokere

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

[diff] [blame]

4091

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

Jeff Johnson

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

[diff] [blame]

4092

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

4093

{

4094

fStatus = FALSE;

4095

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

4096

}

4097

Jeff Johnson

d13512a

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

[diff] [blame]

4098

Kiran Kumar Lokere

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

[diff] [blame]

4099

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

Jeff Johnson

d13512a

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

[diff] [blame]

4100

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4101

{

4102

fStatus = FALSE;

4103

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

4104

}

4105

Jeff Johnson

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

[diff] [blame]

4106

#ifdef WLAN_FEATURE_11AC

4107

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

4108

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

4109

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

4110

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

4111

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

4112

(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]

4118

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

Jeff Johnson

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

[diff] [blame]

4119

Kiran Kumar Lokere

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

[diff] [blame]

4120

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

Jeff Johnson

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

[diff] [blame]

4121

temp, NULL, eANI_BOOLEAN_FALSE)

4122

==eHAL_STATUS_FAILURE)

4123

{

4124

fStatus = FALSE;

4125

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

4126

}

4127

4128

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

Kiran Kumar Lokere

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

[diff] [blame]

4129

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

Jeff Johnson

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

[diff] [blame]

4130

Kiran Kumar Lokere

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

[diff] [blame]

4131

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

4132

temp, NULL, eANI_BOOLEAN_FALSE)

4133

==eHAL_STATUS_FAILURE)

4134

{

4135

fStatus = FALSE;

4136

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

4137

}

4138

4139

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

Kiran Kumar Lokere

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

[diff] [blame]

4140

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

Jeff Johnson

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

[diff] [blame]

4141

Kiran Kumar Lokere

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

[diff] [blame]

4142

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

4143

temp, NULL, eANI_BOOLEAN_FALSE)

4144

==eHAL_STATUS_FAILURE)

4145

{

4146

fStatus = FALSE;

4147

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]

4153

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

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

4154

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4155

{

4156

fStatus = FALSE;

4157

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

4158

}

4159

Kiran Kumar Lokere

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

[diff] [blame]

4160

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

Pratik Bhalgat

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

[diff] [blame]

4161

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

4162

==eHAL_STATUS_FAILURE)

4163

{

4164

fStatus = FALSE;

4165

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

4166

}

4167

4168

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

4169

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

4170

Kiran Kumar Lokere

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

[diff] [blame]

4171

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

Pratik Bhalgat

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

[diff] [blame]

4172

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

4173

==eHAL_STATUS_FAILURE)

4174

{

4175

fStatus = FALSE;

4176

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

4177

}

4178

Kiran Kumar Lokere

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

[diff] [blame]

4179

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

Pratik Bhalgat

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

[diff] [blame]

4180

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

4181

==eHAL_STATUS_FAILURE)

4182

{

4183

fStatus = FALSE;

4184

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

4185

}

Gopichand Nakkala

976e325

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

[diff] [blame]

4186

4187

#ifdef WLAN_SOFTAP_VSTA_FEATURE

4188

if(pConfig->fEnableVSTASupport)

4189

{

4190

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

4191

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

4192

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

4197

}

Kiran Kumar Lokere

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

[diff] [blame]

4198

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

Gopichand Nakkala

976e325

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

[diff] [blame]

4199

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4200

{

4201

fStatus = FALSE;

4202

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

4203

}

4204

#endif

Kiran Kumar Lokere

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

[diff] [blame]

4205

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

4206

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

4207

==eHAL_STATUS_FAILURE)

4208

{

4209

fStatus = FALSE;

4210

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

4211

}

Pratik Bhalgat

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

[diff] [blame]

4212

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

4213

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

4214

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4215

{

4216

fStatus = FALSE;

4217

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

4218

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

4219

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

4220

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4221

{

4222

fStatus = FALSE;

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

4223

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]

4224

}

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

4225

4226

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

4227

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4228

{

4229

fStatus = FALSE;

4230

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

4231

}

4232

4233

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

4234

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4235

{

4236

fStatus = FALSE;

4237

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

4238

}

4239

4240

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

4241

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4242

{

4243

fStatus = FALSE;

4244

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

4245

}

4246

Gopichand Nakkala

42bc89e

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

[diff] [blame]

4247

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

4248

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4249

{

4250

fStatus = FALSE;

4251

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

4252

}

4253

Gopichand Nakkala

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

[diff] [blame]

4254

#ifdef FEATURE_WLAN_TDLS

4255

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4256

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,

4257

pConfig->fTDLSUapsdMask, NULL,

4258

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4259

{

4260

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4261

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]

4262

}

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4263

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_BUF_STA_ENABLED,

4264

pConfig->fEnableTDLSBufferSta, NULL,

4265

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4266

{

4267

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4268

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]

4269

}

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4270

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_PUAPSD_INACT_TIME,

4271

pConfig->fTDLSPuapsdInactivityTimer, NULL,

4272

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4273

{

4274

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4275

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]

4276

}

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4277

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,

4278

pConfig->fTDLSRxFrameThreshold, NULL,

4279

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4280

{

4281

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4282

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]

4283

}

4284

#endif

4285

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4286

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,

4287

pConfig->fEnableAdaptRxDrain, NULL,

4288

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4289

{

4290

fStatus = FALSE;

4291

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

4292

}

Yue Ma

0fd2387

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

[diff] [blame]

4293

4294

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_FLEX_CONNECT_POWER_FACTOR,

4295

pConfig->flexConnectPowerFactor, NULL,

4296

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4297

{

4298

fStatus = FALSE;

4299

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

4300

"WNI_CFG_FLEX_CONNECT_POWER_FACTOR to CCM");

4301

}

4302

Madan Mohan Koyyalamudi

ca45457

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

[diff] [blame]

4303

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ANTENNA_DIVESITY,

4304

pConfig->antennaDiversity, NULL,

4305

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4306

{

4307

fStatus = FALSE;

4308

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

4309

}

4310

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

4316

Kiran Kumar Lokere

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

[diff] [blame]

4317

\brief hdd_init_set_sme_config() -

Jeff Johnson

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

[diff] [blame]

4318

4319

This function initializes the sme configuration parameters

Kiran Kumar Lokere

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

[diff] [blame]

4320

Jeff Johnson

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

[diff] [blame]

4321

\param - pHddCtx - Pointer to the HDD Adapter.

Kiran Kumar Lokere

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

[diff] [blame]

4322

Jeff Johnson

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

[diff] [blame]

4323

\return - 0 for success, non zero for failure

Kiran Kumar Lokere

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

[diff] [blame]

4324

Jeff Johnson

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

[diff] [blame]

4325

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

4326

4327

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

4328

{

4329

VOS_STATUS status = VOS_STATUS_SUCCESS;

4330

eHalStatus halStatus;

4331

tSmeConfigParams smeConfig;

4332

4333

hdd_config_t *pConfig = pHddCtx->cfg_ini;

4334

4335

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

4336

Kiran Kumar Lokere

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

[diff] [blame]

4337

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

Jeff Johnson

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

[diff] [blame]

4338

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

4339

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

4340

4341

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

2012-09-28 15:34:08 -0700

[diff] [blame]

4342

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

4343

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

Jeff Johnson

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

[diff] [blame]

4344

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

4345

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

4346

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

4347

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

4348

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

4349

4350

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

4351

4352

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

4353

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

4354

smeConfig.csrConfig.TxRate = pConfig->TxRate;

4355

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

4356

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

4357

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

4358

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

4359

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

4360

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

4361

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

4362

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

4363

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

4364

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

4365

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

4366

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

4367

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

4368

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

Kiran Kumar Lokere

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

[diff] [blame]

4369

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

Jeff Johnson

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

[diff] [blame]

4370

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

4371

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

4372

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

4373

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Kiran Kumar Lokere

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

[diff] [blame]

4374

smeConfig.csrConfig.nActiveMaxChnTimeBtc = pConfig->nActiveMaxChnTimeBtc;

4375

smeConfig.csrConfig.nActiveMinChnTimeBtc = pConfig->nActiveMinChnTimeBtc;

Kiran Kumar Lokere

458d732

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

[diff] [blame]

4376

smeConfig.csrConfig.disableAggWithBtc = pConfig->disableAggWithBtc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

4377

#ifdef WLAN_AP_STA_CONCURRENCY

4378

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

4379

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

4380

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

4381

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

4382

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Sudhir Sattayappa Kohalli

eb97d50

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

[diff] [blame]

4383

smeConfig.csrConfig.nNumStaChanCombinedConc = pConfig->nNumStaChanCombinedConc;

4384

smeConfig.csrConfig.nNumP2PChanCombinedConc = pConfig->nNumP2PChanCombinedConc;

4385

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

4386

#endif

Jeff Johnson

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

[diff] [blame]

4387

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

4388

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

4389

4390

#if defined WLAN_FEATURE_VOWIFI

4391

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

4392

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

4393

#endif

4394

//Remaining config params not obtained from registry

4395

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

4396

#ifdef WLAN_FEATURE_11AC

4397

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

4398

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

4399

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Ravi Joshi

83bfaa1

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

[diff] [blame]

4400

smeConfig.csrConfig.enableVhtFor24GHz = pConfig->enableVhtFor24GHzBand;

Jeff Johnson

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

[diff] [blame]

4401

#endif

Shailender Karmuchi

a734f33

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

[diff] [blame]

4402

smeConfig.csrConfig.AdHocChannel5G = pConfig->AdHocChannel5G;

4403

smeConfig.csrConfig.AdHocChannel24 = pConfig->AdHocChannel24G;

Kiran Kumar Lokere

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

[diff] [blame]

4404

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

4405

smeConfig.csrConfig.HeartbeatThresh50 = 40;

4406

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

4407

if (pConfig->nBandCapability == eCSR_BAND_24)

4408

{

4409

smeConfig.csrConfig.Is11hSupportEnabled = 0;

4410

} else {

4411

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

4412

}

Kiran Kumar Lokere

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

[diff] [blame]

4413

smeConfig.csrConfig.cbChoice = 0;

4414

smeConfig.csrConfig.bgScanInterval = 0;

4415

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

Jeff Johnson

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

[diff] [blame]

4416

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

4417

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

4418

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

4419

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

4420

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

Srinivas Girigowda

bbd16eb

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

[diff] [blame]

4421

smeConfig.csrConfig.nRoamIntraBand = pConfig->nRoamIntraBand;

Varun Reddy Yeturu

920df21

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

[diff] [blame]

4422

smeConfig.csrConfig.nProbes = pConfig->nProbes;

Srinivas Girigowda

6cf0b82

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

[diff] [blame]

4423

4424

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

4425

{

4426

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,

4427

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

4428

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

4429

__func__, pConfig->nRoamScanHomeAwayTime,

4430

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

4431

pConfig->nRoamScanHomeAwayTime = 0;

4432

}

Varun Reddy Yeturu

920df21

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

[diff] [blame]

4433

smeConfig.csrConfig.nRoamScanHomeAwayTime = pConfig->nRoamScanHomeAwayTime;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

4434

#endif

Jeff Johnson

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

[diff] [blame]

4435

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

4436

Jeff Johnson

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

[diff] [blame]

4437

//FIXME 11d config is hardcoded

Jeff Johnson

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

[diff] [blame]

4438

if ( VOS_STA_SAP_MODE != hdd_get_conparam())

4439

{

4440

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

Jeff Johnson

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

[diff] [blame]

4441

Jeff Johnson

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

[diff] [blame]

4442

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

4443

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

4444

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

4445

* come from NV as per our current implementation */

Jeff Johnson

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

[diff] [blame]

4446

}

Jeff Johnson

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

[diff] [blame]

4447

else

4448

{

4449

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

4450

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

Jeff Johnson

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

[diff] [blame]

4451

Jeff Johnson

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

[diff] [blame]

4452

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

4453

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

4454

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

4455

}

Jeff Johnson

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

[diff] [blame]

4456

hdd_set_power_save_config(pHddCtx, &smeConfig);

4457

hdd_set_btc_config(pHddCtx);

4458

Kiran Kumar Lokere

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

[diff] [blame]

4459

#ifdef WLAN_FEATURE_VOWIFI_11R

Jeff Johnson

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

[diff] [blame]

4460

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

4461

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4462

#ifdef FEATURE_WLAN_LFR

4463

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

4464

#endif

Jeff Johnson

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

[diff] [blame]

4465

#ifdef FEATURE_WLAN_CCX

4466

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

4467

if( pConfig->isCcxIniFeatureEnabled )

4468

{

4469

pConfig->isFastTransitionEnabled = TRUE;

4470

}

Jeff Johnson

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

[diff] [blame]

4471

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4472

#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]

4473

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

4474

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

4475

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

4476

#endif

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4477

#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD

4478

smeConfig.csrConfig.isRoamOffloadScanEnabled = pConfig->isRoamOffloadScanEnabled;

Srinivas Girigowda

830bbd0

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

[diff] [blame]

4479

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = pConfig->bFastRoamInConIniFeatureEnabled;

4480

4481

if (0 == smeConfig.csrConfig.isRoamOffloadScanEnabled)

4482

{

4483

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

4484

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = 0;

4485

}

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4486

#endif

Jeff Johnson

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

[diff] [blame]

4487

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

4488

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

4489

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

Kiran Kumar Lokere

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

[diff] [blame]

4490

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

4491

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

Jeff Johnson

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

[diff] [blame]

4492

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

Kiran Kumar Lokere

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

[diff] [blame]

4493

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

Jeff Johnson

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

[diff] [blame]

4494

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

Srinivas Girigowda

de69741

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

[diff] [blame]

4495

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

Kiran Kumar Lokere

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

[diff] [blame]

4496

hdd_string_to_u8_array( pConfig->neighborScanChanList,

4497

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

4498

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

Jeff Johnson

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

[diff] [blame]

4499

WNI_CFG_VALID_CHANNEL_LIST_LEN );

4500

#endif

4501

4502

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

4503

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

4504

Kiran Kumar Lokere

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

[diff] [blame]

4505

//Enable/Disable MCC

Jeff Johnson

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

[diff] [blame]

4506

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

4507

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

4508

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

4509

//Scan Results Aging Time out value

4510

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

4511

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

4512

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

4513

Gopichand Nakkala

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

[diff] [blame]

4514

/* update SSR config */

4515

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

Gopichand Nakkala

86e4266

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

[diff] [blame]

4516

/* Update the Directed scan offload setting */

4517

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

Gopichand Nakkala

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

[diff] [blame]

4518

Kiran Kumar Lokere

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

[diff] [blame]

4519

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

Jeff Johnson

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

[diff] [blame]

4520

if ( !HAL_STATUS_SUCCESS( halStatus ) )

4521

{

4522

status = VOS_STATUS_E_FAILURE;

4523

}

4524

Kiran Kumar Lokere

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

[diff] [blame]

4525

4526

return status;

Jeff Johnson

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

[diff] [blame]

}

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

4531

4532

\brief hdd_execute_config_command() -

4533

4534

This function executes an arbitrary configuration set command

4535

4536

\param - pHddCtx - Pointer to the HDD Adapter.

4537

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

4538

4539

4540

\return - 0 for success, non zero for failure

4541

4542

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

4543

4544

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

4545

{

4546

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

4547

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;

4556

unsigned int idx;

4557

unsigned int i;

4558

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

4559

int rv;

Jeff Johnson

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

[diff] [blame]

4560

4561

// assume failure until proven otherwise

4562

vstatus = VOS_STATUS_E_FAILURE;

4563

4564

// clone the command so that we can manipulate it

4565

clone = kstrdup(command, GFP_ATOMIC);

4566

if (NULL == clone)

4567

{

4568

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4569

__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

4574

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

4575

pCmd = clone;

4576

4577

// 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]

4583

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

4588

name = pCmd;

4589

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]

4597

__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

4607

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4608

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

4613

if ('\0' == *value_str)

4614

{

4615

// did not find a value

4616

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4617

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

4622

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

4623

{

4624

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

{

// found a match

break;

}

}

if (tableSize == idx)

4631

{

4632

// did not match the name

4633

hddLog(LOGE, "%s: invalid command, unknown configuration item:[%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;

}

pRegEntry = &g_registry_table[idx];

4639

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

4640

{

4641

// does not support dynamic configuration

4642

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4643

"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;

4648

4649

switch (pRegEntry->RegType)

4650

{

4651

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4652

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

4653

if (rv < 0)

4654

goto done;

Jeff Johnson

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

[diff] [blame]

4655

if (value < pRegEntry->VarMin)

4656

{

4657

// out of range

4658

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4659

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4660

goto done;

4661

}

4662

if (value > pRegEntry->VarMax)

4663

{

4664

// out of range

4665

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4666

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4667

goto done;

4668

}

4669

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

4670

break;

4671

4672

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4673

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

4674

if (rv < 0)

4675

goto done;

Jeff Johnson

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

[diff] [blame]

4676

if (value < pRegEntry->VarMin)

4677

{

4678

// out of range

4679

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4680

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4681

goto done;

4682

}

4683

if (value > pRegEntry->VarMax)

4684

{

4685

// out of range

4686

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4687

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4688

goto done;

4689

}

4690

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

4691

break;

4692

4693

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4694

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

4695

if (rv < 0)

4696

goto done;

Jeff Johnson

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

[diff] [blame]

4697

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

4698

{

4699

// out of range

4700

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4701

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

Jeff Johnson

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

[diff] [blame]

4702

goto done;

4703

}

4704

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

4705

{

4706

// out of range

4707

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4708

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

Jeff Johnson

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

[diff] [blame]

4709

goto done;

4710

}

4711

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

4712

break;

4713

4714

case WLAN_PARAM_String:

4715

len_value_str = strlen(value_str);

4716

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

{

// too big

hddLog(LOGE,

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

4721

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4722

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

4723

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

4724

goto done;

4725

}

4726

// copy string plus NUL

4727

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

4728

break;

4729

4730

case WLAN_PARAM_MacAddr:

4731

len_value_str = strlen(value_str);

4732

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

4737

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4738

__func__, value_str,

Jeff Johnson