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

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

[diff] [blame]

3168

#endif

3169

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

3170

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

3171

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

3172

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

3173

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

3174

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

3175

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

3176

3177

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

3178

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

3179

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

3180

#ifdef WLAN_BTAMP_FEATURE

3181

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

3182

#endif //WLAN_BTAMP_FEATURE

3183

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

3184

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

3185

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

3186

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

3187

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

3188

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

3189

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

3190

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

3191

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

3192

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

3193

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

3194

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

3195

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]

3196

#ifdef WLAN_FEATURE_11AC

3197

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

3198

#endif

3199

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

3200

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

3201

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]

3202

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]

3203

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]

3204

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]

3205

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]

3206

Leo Chang

64d68bc

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

[diff] [blame]

3207

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

3208

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]

3209

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]

3210

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]

3211

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]

3212

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

3213

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

3214

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

3215

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

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3216

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

3217

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

krunal soni

e9002db

2013-11-25 14:24:17 -0800

[diff] [blame]

3218

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

Madan Mohan Koyyalamudi

2558bc9

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

[diff] [blame]

3219

Jeff Johnson

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

[diff] [blame]

}

Gopichand Nakkala

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

[diff] [blame]

3223

Jeff Johnson

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

[diff] [blame]

3224

#define CFG_VALUE_MAX_LEN 256

3225

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

3226

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

3227

{

3228

unsigned int idx;

3229

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

3230

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

3231

v_U32_t value;

3232

char valueStr[CFG_VALUE_MAX_LEN];

3233

char configStr[CFG_ENTRY_MAX_LEN];

3234

char *fmt;

3235

void *pField;

3236

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

3241

*pCur = '\0';

3242

Kiran Kumar Lokere

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

[diff] [blame]

3243

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

Jeff Johnson

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

[diff] [blame]

3244

{

3245

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

3246

3247

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

3248

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

Kiran Kumar Lokere

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

[diff] [blame]

3249

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

Jeff Johnson

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

[diff] [blame]

3250

{

3251

value = 0;

3252

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

3253

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

3266

}

3267

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3268

{

3269

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

3270

}

3271

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3272

{

3273

pMacAddr = (v_MACADDR_t *) pField;

3274

snprintf(valueStr, CFG_VALUE_MAX_LEN,

3275

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

3286

}

Sameer Thalappil

b0a3023

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

[diff] [blame]

3287

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

3292

"*" : "");

3293

3294

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

3295

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

3296

#ifdef RETURN_IN_BUFFER

3297

if (curlen <= buflen)

3298

{

3299

// copy string + '\0'

3300

memcpy(pCur, configStr, curlen+1);

3301

3302

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

3309

return VOS_STATUS_E_RESOURCES;

3310

}

3311

#else

3312

printk(KERN_CRIT "%s", configStr);

3313

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

3318

// notify application that output is in system log

3319

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

3320

#endif // RETURN_IN_BUFFER

3321

3322

return VOS_STATUS_SUCCESS;

3323

}

3324

3325

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

Kiran Kumar Lokere

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

[diff] [blame]

3326

char *name, char** value)

Jeff Johnson

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

[diff] [blame]

3327

{

3328

VOS_STATUS status = VOS_STATUS_E_FAILURE;

3329

unsigned long i;

3330

3331

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

3332

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

3333

*value = iniTable[i].value;

3334

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

3335

WLAN_INI_FILE, name, *value);

3336

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

3344

{

3345

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

3346

return c-'0';

3347

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

3348

return c-'a'+10;

3349

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)

3357

{

3358

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

3359

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

3360

unsigned int idx;

3361

void *pField;

3362

char *value_str = NULL;

3363

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

3368

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

3369

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

3370

v_U32_t cbOutString;

3371

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3372

int rv;

Jeff Johnson

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

[diff] [blame]

3373

3374

// sanity test

3375

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

3376

{

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3377

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3378

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

3379

}

3380

3381

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

3382

{

3383

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

3384

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

3385

3386

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

3387

3388

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

3389

{

3390

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

3391

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3392

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3393

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

3398

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

3399

{

3400

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

3401

// If not, use the default value.

3402

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

Jeff Johnson

2013-10-26 19:17:13 -0700

[diff] [blame]

3403

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3404

if (rv < 0) {

3405

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

3406

__func__, pRegEntry->RegName);

3407

value = pRegEntry->VarDefault;

3408

}

Jeff Johnson

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

[diff] [blame]

3409

}

3410

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

Jeff Johnson

2013-10-26 19:17:13 -0700

[diff] [blame]

3411

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3412

if (rv < 0) {

3413

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

3414

__func__, pRegEntry->RegName);

3415

value = pRegEntry->VarDefault;

3416

}

Jeff Johnson

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

[diff] [blame]

3417

}

3418

else {

3419

value = pRegEntry->VarDefault;

3420

}

3421

3422

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

3423

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

3424

{

3425

if ( value > pRegEntry->VarMax )

3426

{

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3427

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3428

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

Jeff Johnson

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

[diff] [blame]

3429

value = pRegEntry->VarMax;

3430

}

3431

3432

if ( value < pRegEntry->VarMin )

3433

{

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3434

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3435

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

Jeff Johnson

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

[diff] [blame]

3436

value = pRegEntry->VarMin;

3437

}

3438

}

3439

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

3440

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3441

{

3442

if ( value > pRegEntry->VarMax )

3443

{

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3444

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3445

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

Jeff Johnson

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

[diff] [blame]

3446

value = pRegEntry->VarDefault;

3447

}

3448

3449

if ( value < pRegEntry->VarMin )

3450

{

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3451

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3452

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

Jeff Johnson

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

[diff] [blame]

3453

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3458

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

3459

}

3460

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

3461

{

3462

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

3463

// If not, use the default value.

3464

if (VOS_STATUS_SUCCESS == match_status)

3465

{

Jeff Johnson

2013-10-26 19:17:13 -0700

[diff] [blame]

3466

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3467

if (rv < 0) {

3468

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

3469

__func__, pRegEntry->RegName);

3470

svalue = (v_S31_t)pRegEntry->VarDefault;

3471

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

3476

}

3477

3478

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

3479

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

3480

{

3481

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

3482

{

3483

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

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3484

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

Jeff Johnson

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

[diff] [blame]

3485

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

3486

svalue = (v_S31_t)pRegEntry->VarMax;

3487

}

3488

3489

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

3490

{

3491

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

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3492

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

Jeff Johnson

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

[diff] [blame]

3493

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

3494

svalue = (v_S31_t)pRegEntry->VarMin;

3495

}

3496

}

3497

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

3498

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3499

{

3500

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

3501

{

3502

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

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3503

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3504

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3505

(int)pRegEntry->VarMax,

3506

(int)pRegEntry->VarDefault );

3507

svalue = (v_S31_t)pRegEntry->VarDefault;

3508

}

3509

3510

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

3511

{

3512

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

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

3513

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3514

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3515

(int)pRegEntry->VarMin,

3516

(int)pRegEntry->VarDefault);

3517

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3522

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

3523

}

3524

// Handle string parameters

3525

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3526

{

3527

#ifdef WLAN_CFG_DEBUG

3528

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]

3529

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

Jeff Johnson

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

[diff] [blame]

3530

#endif

3531

Kiran Kumar Lokere

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

[diff] [blame]

3532

if ( match_status == VOS_STATUS_SUCCESS)

Jeff Johnson

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

[diff] [blame]

3533

{

3534

len_value_str = strlen(value_str);

3535

3536

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

Kiran Kumar Lokere

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

[diff] [blame]

3537

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]

3538

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

Jeff Johnson

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

[diff] [blame]

3539

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

3540

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

3541

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

}

else

{

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

3546

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

3547

}

3548

}

Kiran Kumar Lokere

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

[diff] [blame]

3549

else

Jeff Johnson

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

[diff] [blame]

3550

{

3551

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

3552

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

3553

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

Kiran Kumar Lokere

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

[diff] [blame]

3554

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

Jeff Johnson

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

[diff] [blame]

3555

}

3556

}

3557

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3558

{

3559

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

Kiran Kumar Lokere

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

[diff] [blame]

3560

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

3561

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

Jeff Johnson

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

[diff] [blame]

3562

continue;

3563

}

3564

candidate = (char*)pRegEntry->VarDefault;

3565

if ( match_status == VOS_STATUS_SUCCESS) {

3566

len_value_str = strlen(value_str);

3567

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

Kiran Kumar Lokere

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

[diff] [blame]

3568

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]

3569

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

Jeff Johnson

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

[diff] [blame]

3570

}

3571

else

3572

candidate = value_str;

3573

}

3574

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

3575

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

3576

{

Kiran Kumar Lokere

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

[diff] [blame]

3577

((char*)pField)[i] =

3578

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

3583

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]

3584

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3585

}

3586

3587

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

3588

if( (match_status == VOS_STATUS_SUCCESS) &&

3589

(idx < MAX_CFG_INI_ITEMS) )

3590

{

3591

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

}

}

print_hdd_cfg(pHddCtx);

3596

3597

return( ret_status );

3598

}

3599

3600

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

3601

{

Kiran Kumar Lokere

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

[diff] [blame]

3602

switch (dot11Mode)

Jeff Johnson

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

[diff] [blame]

3603

{

3604

case (eHDD_DOT11_MODE_abg):

3605

return eCSR_DOT11_MODE_abg;

3606

case (eHDD_DOT11_MODE_11b):

3607

return eCSR_DOT11_MODE_11b;

3608

case (eHDD_DOT11_MODE_11g):

3609

return eCSR_DOT11_MODE_11g;

3610

default:

3611

case (eHDD_DOT11_MODE_11n):

3612

return eCSR_DOT11_MODE_11n;

3613

case (eHDD_DOT11_MODE_11g_ONLY):

3614

return eCSR_DOT11_MODE_11g_ONLY;

3615

case (eHDD_DOT11_MODE_11n_ONLY):

3616

return eCSR_DOT11_MODE_11n_ONLY;

3617

case (eHDD_DOT11_MODE_11b_ONLY):

3618

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

3619

#ifdef WLAN_FEATURE_11AC

3620

case (eHDD_DOT11_MODE_11ac_ONLY):

3621

return eCSR_DOT11_MODE_11ac_ONLY;

3622

case (eHDD_DOT11_MODE_11ac):

3623

return eCSR_DOT11_MODE_11ac;

3624

#endif

Jeff Johnson

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

[diff] [blame]

3625

case (eHDD_DOT11_MODE_AUTO):

3626

return eCSR_DOT11_MODE_AUTO;

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3631

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

Jeff Johnson

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

[diff] [blame]

3632

{

3633

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3634

tSmeBtcConfig btcParams;

Wilson Tsao

f8b3794

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

[diff] [blame]

3635

int i;

Kiran Kumar Lokere

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

[diff] [blame]

3636

Jeff Johnson

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

[diff] [blame]

3637

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

3638

3639

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

3640

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

3641

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

3642

Jeff Johnson

32d95a3

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

[diff] [blame]

3643

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

3644

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

3645

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

3646

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

3647

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

3648

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

3649

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

3650

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

3651

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

3652

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

3653

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

3654

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

3655

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

3656

Wilson Tsao

f8b3794

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

[diff] [blame]

3657

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

3658

{

3659

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

3660

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

3661

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

3662

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

3663

}

3664

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

3665

{

3666

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

3667

}

3668

btcParams.mwsCoexModemBackoff = pConfig->mwsCoexModemBackoff;

3669

btcParams.SARPowerBackoff = pConfig->SARPowerBackoff;

3670

Jeff Johnson

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

[diff] [blame]

3671

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

3672

}

3673

Kiran Kumar Lokere

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

[diff] [blame]

3674

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

Jeff Johnson

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

[diff] [blame]

3675

{

3676

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3677

3678

tPmcBmpsConfigParams bmpsParams;

Kiran Kumar Lokere

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

[diff] [blame]

3679

Jeff Johnson

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

[diff] [blame]

3680

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

Kiran Kumar Lokere

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

[diff] [blame]

3681

Jeff Johnson

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

[diff] [blame]

3682

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

3683

{

3684

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

3685

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

3686

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3687

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3688

}

3689

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

3690

{

3691

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

3692

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

3693

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3694

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3695

}

3696

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

3697

{

3698

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

3699

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

3700

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3701

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3702

}

3703

3704

if (pConfig->fIsImpsEnabled)

3705

{

3706

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

3711

}

3712

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

3713

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

3714

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

3715

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

3716

Jeff Johnson

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

[diff] [blame]

3717

if (pConfig->fIsBmpsEnabled)

3718

{

3719

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

3724

}

3725

3726

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

3727

3728

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

3729

{

3730

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

3731

}

Kiran Kumar Lokere

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

[diff] [blame]

3732

Jeff Johnson

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

[diff] [blame]

3733

if(pConfig->fIsAutoBmpsTimerEnabled)

3734

{

3735

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3741

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 )

3746

{

3747

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

3751

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

3752

{

3753

int val;

3754

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

3755

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

3756

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

3757

{

3758

intArray[*len] = (tANI_U8) val;

3759

*len += 1;

3760

}

3761

s = strpbrk( s, "," );

3762

if( s )

3763

s++;

3764

}

Jeff Johnson

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

[diff] [blame]

3765

3766

return VOS_STATUS_SUCCESS;

Kiran Kumar Lokere

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

[diff] [blame]

3767

Jeff Johnson

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

[diff] [blame]

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

3773

{

3774

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

3775

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3776

tANI_U32 val;

3777

#endif

Jeff Johnson

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

[diff] [blame]

3778

3779

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

3780

tSirMacHTCapabilityInfo htCapInfo;

3781

Jeff Johnson

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

[diff] [blame]

3782

Kiran Kumar Lokere

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

[diff] [blame]

3783

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

Jeff Johnson

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

[diff] [blame]

3784

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

3785

{

3786

fStatus = FALSE;

3787

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

3788

}

Kiran Kumar Lokere

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

[diff] [blame]

3789

3790

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

Jeff Johnson

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

[diff] [blame]

3791

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3792

{

3793

fStatus = FALSE;

3794

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

3795

}

3796

3797

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

3798

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3799

{

3800

fStatus = FALSE;

3801

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

3802

}

3803

3804

if ( 0 != pConfig->Cfg1Id )

3805

{

Kiran Kumar Lokere

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

[diff] [blame]

3806

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

Jeff Johnson

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

[diff] [blame]

3807

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3808

{

3809

fStatus = FALSE;

3810

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

3811

}

Kiran Kumar Lokere

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

[diff] [blame]

3812

Jeff Johnson

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

[diff] [blame]

3813

}

3814

3815

if ( 0 != pConfig->Cfg2Id )

3816

{

Kiran Kumar Lokere

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

[diff] [blame]

3817

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

Jeff Johnson

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

[diff] [blame]

3818

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3819

{

3820

fStatus = FALSE;

3821

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

}

}

if ( 0 != pConfig->Cfg3Id )

3826

{

Kiran Kumar Lokere

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

[diff] [blame]

3827

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

Jeff Johnson

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

[diff] [blame]

3828

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3829

{

3830

fStatus = FALSE;

3831

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

}

}

if ( 0 != pConfig->Cfg4Id )

3836

{

Kiran Kumar Lokere

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

[diff] [blame]

3837

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

Jeff Johnson

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

[diff] [blame]

3838

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3839

{

3840

fStatus = FALSE;

3841

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

}

}

if ( 0 != pConfig->Cfg5Id )

3846

{

Kiran Kumar Lokere

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

[diff] [blame]

3847

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

Jeff Johnson

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

[diff] [blame]

3848

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3849

{

3850

fStatus = FALSE;

3851

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

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3855

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

Jeff Johnson

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

[diff] [blame]

3856

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3857

{

3858

fStatus = FALSE;

3859

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

3860

}

Kiran Kumar Lokere

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

[diff] [blame]

3861

3862

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

Jeff Johnson

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

[diff] [blame]

3863

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3864

{

3865

fStatus = FALSE;

3866

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

3867

}

3868

Kiran Kumar Lokere

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

[diff] [blame]

3869

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

Jeff Johnson

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

[diff] [blame]

3870

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

3871

{

3872

fStatus = FALSE;

3873

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

3874

}

3875

3876

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

3877

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3878

{

3879

fStatus = FALSE;

3880

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

3881

}

3882

Kiran Kumar Lokere

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

[diff] [blame]

3883

if (pConfig->fIsAutoIbssBssid)

Jeff Johnson

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

[diff] [blame]

3884

{

Kiran Kumar Lokere

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

[diff] [blame]

3885

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

Jeff Johnson

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

[diff] [blame]

3886

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

3887

{

3888

fStatus = FALSE;

3889

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

3890

}

3891

}

3892

else

Kiran Kumar Lokere

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

[diff] [blame]

3893

{

Jeff Johnson

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

[diff] [blame]

3894

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

3895

{

3896

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

Arif Hussain

24bafea

2013-11-15 15:10:03 -0800

[diff] [blame]

3897

"MAC Addr (IBSS BSSID) read from Registry is: " MAC_ADDRESS_STR,

3898

MAC_ADDR_ARRAY(pConfig->IbssBssid.bytes));

Kiran Kumar Lokere

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

[diff] [blame]

3899

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

Jeff Johnson

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

[diff] [blame]

3900

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

3901

{

3902

fStatus = FALSE;

3903

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]

3913

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

Jeff Johnson

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

[diff] [blame]

3914

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3915

{

3916

fStatus = FALSE;

3917

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

3918

}

3919

Kiran Kumar Lokere

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

[diff] [blame]

3920

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

Jeff Johnson

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

[diff] [blame]

3921

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3922

{

3923

fStatus = FALSE;

3924

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

3925

}

3926

3927

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

3928

{

3929

fStatus = FALSE;

3930

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

3931

}

3932

Kiran Kumar Lokere

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

[diff] [blame]

3933

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

Jeff Johnson

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

[diff] [blame]

3934

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3935

{

3936

fStatus = FALSE;

3937

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

3938

}

Kiran Kumar Lokere

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

[diff] [blame]

3939

Jeff Johnson

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

[diff] [blame]

3940

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

3941

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3942

{

3943

fStatus = FALSE;

3944

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

3945

}

3946

Jeff Johnson

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

[diff] [blame]

3947

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

3948

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3949

{

3950

fStatus = FALSE;

3951

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

3952

}

3953

Kiran Kumar Lokere

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

[diff] [blame]

3954

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

Jeff Johnson

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

[diff] [blame]

3955

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3956

{

3957

fStatus = FALSE;

3958

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

3959

}

3960

Kiran Kumar Lokere

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

[diff] [blame]

3961

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

Jeff Johnson

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

[diff] [blame]

3962

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3963

{

3964

fStatus = FALSE;

3965

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

3966

}

3967

Kiran Kumar Lokere

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

[diff] [blame]

3968

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

Jeff Johnson

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

[diff] [blame]

3969

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3970

{

3971

fStatus = FALSE;

3972

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

3973

}

3974

Kiran Kumar Lokere

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

[diff] [blame]

3975

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

Jeff Johnson

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

[diff] [blame]

3976

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3977

{

3978

fStatus = FALSE;

3979

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

3980

}

3981

Kiran Kumar Lokere

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

[diff] [blame]

3982

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

Jeff Johnson

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

[diff] [blame]

3983

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3984

{

3985

fStatus = FALSE;

3986

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

3987

}

3988

Kiran Kumar Lokere

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

[diff] [blame]

3989

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

Jeff Johnson

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

[diff] [blame]

3990

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3991

{

3992

fStatus = FALSE;

3993

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

3994

}

3995

Kiran Kumar Lokere

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

[diff] [blame]

3996

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

Jeff Johnson

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

[diff] [blame]

3997

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3998

{

3999

fStatus = FALSE;

4000

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

4001

}

4002

Kiran Kumar Lokere

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

[diff] [blame]

4003

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

Jeff Johnson

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

[diff] [blame]

4004

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4005

{

4006

fStatus = FALSE;

4007

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]

4008

}

Jeff Johnson

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

[diff] [blame]

4009

Kiran Kumar Lokere

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

[diff] [blame]

4010

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

Jeff Johnson

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

[diff] [blame]

4011

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4012

{

4013

fStatus = FALSE;

4014

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

4015

}

Kiran Kumar Lokere

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

[diff] [blame]

4016

Sejal Chauhan

bcde8bc

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

[diff] [blame]

4017

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

4018

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4019

{

4020

fStatus = FALSE;

4021

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

4022

}

4023

Madan Mohan Koyyalamudi

2558bc9

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

[diff] [blame]

4024

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

4025

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4026

{

4027

fStatus = FALSE;

4028

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]

4032

#if defined WLAN_FEATURE_VOWIFI

Kiran Kumar Lokere

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

[diff] [blame]

4033

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

Jeff Johnson

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

[diff] [blame]

4034

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4035

{

4036

fStatus = FALSE;

4037

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

4038

}

4039

Kiran Kumar Lokere

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

[diff] [blame]

4040

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

Jeff Johnson

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

[diff] [blame]

4041

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4042

{

4043

fStatus = FALSE;

4044

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

4045

}

4046

Kiran Kumar Lokere

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

[diff] [blame]

4047

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

Jeff Johnson

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

[diff] [blame]

4048

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4049

{

4050

fStatus = FALSE;

4051

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

4052

}

4053

Kiran Kumar Lokere

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

[diff] [blame]

4054

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

Jeff Johnson

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

[diff] [blame]

4055

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4056

#endif

4057

Kiran Kumar Lokere

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

[diff] [blame]

4058

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

Jeff Johnson

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

[diff] [blame]

4059

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4060

{

4061

fStatus = FALSE;

4062

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

4063

}

4064

Kiran Kumar Lokere

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

[diff] [blame]

4065

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

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_TELE_BCN_WAKEUP_EN configuration info to CCM\n" );

4070

}

4071

Kiran Kumar Lokere

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

[diff] [blame]

4072

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

Jeff Johnson

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

[diff] [blame]

4073

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4074

{

4075

fStatus = FALSE;

4076

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

4077

}

4078

Kiran Kumar Lokere

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

[diff] [blame]

4079

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

Jeff Johnson

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

[diff] [blame]

4080

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4081

{

4082

fStatus = FALSE;

4083

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

4084

}

4085

Kiran Kumar Lokere

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

[diff] [blame]

4086

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]

4087

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4088

{

4089

fStatus = FALSE;

4090

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

4091

}

4092

Kiran Kumar Lokere

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

[diff] [blame]

4093

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]

4094

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4095

{

4096

fStatus = FALSE;

4097

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

4098

}

4099

4100

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

4101

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4102

{

4103

fStatus = FALSE;

4104

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

4105

}

4106

Kiran Kumar Lokere

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

[diff] [blame]

4107

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

Jeff Johnson

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

[diff] [blame]

4108

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4109

{

4110

fStatus = FALSE;

4111

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

4112

}

Kiran Kumar Lokere

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

[diff] [blame]

4113

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

Jeff Johnson

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

[diff] [blame]

4114

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4115

{

4116

fStatus = FALSE;

4117

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

4118

}

4119

4120

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

4121

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4122

{

4123

fStatus = FALSE;

4124

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]

4125

}

Jeff Johnson

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

[diff] [blame]

4126

Jeff Johnson

eed2dca

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

[diff] [blame]

4127

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

Jeff Johnson

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

[diff] [blame]

4128

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

Jeff Johnson

eed2dca

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

[diff] [blame]

4129

{

4130

fStatus = FALSE;

4131

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

4132

}

Kiran Kumar Lokere

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

[diff] [blame]

4133

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

Jeff Johnson

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

[diff] [blame]

4134

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4135

{

4136

fStatus = FALSE;

4137

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

4138

}

Kiran Kumar Lokere

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

[diff] [blame]

4139

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

Jeff Johnson

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

[diff] [blame]

4140

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4141

{

4142

fStatus = FALSE;

4143

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

4144

}

4145

Kiran Kumar Lokere

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

[diff] [blame]

4146

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

Jeff Johnson

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

[diff] [blame]

4147

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4148

{

4149

fStatus = FALSE;

4150

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

4151

}

Kiran Kumar Lokere

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

[diff] [blame]

4152

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

Jeff Johnson

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

[diff] [blame]

4153

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4154

{

4155

fStatus = FALSE;

4156

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

4157

}

4158

Jeff Johnson

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

[diff] [blame]

4159

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

4160

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4161

{

4162

fStatus = FALSE;

4163

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

4164

}

4165

Kiran Kumar Lokere

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

[diff] [blame]

4166

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

Jeff Johnson

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

[diff] [blame]

4167

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

4168

==eHAL_STATUS_FAILURE)

4169

{

4170

fStatus = FALSE;

4171

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

4172

}

4173

Kiran Kumar Lokere

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

[diff] [blame]

4174

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

Jeff Johnson

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

[diff] [blame]

4175

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

4176

==eHAL_STATUS_FAILURE)

4177

{

4178

fStatus = FALSE;

4179

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

4180

}

4181

Kiran Kumar Lokere

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

[diff] [blame]

4182

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

Jeff Johnson

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

[diff] [blame]

4183

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

4184

{

4185

fStatus = FALSE;

4186

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

4187

}

4188

Jeff Johnson

d13512a

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

[diff] [blame]

4189

Kiran Kumar Lokere

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

[diff] [blame]

4190

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

Jeff Johnson

d13512a

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

[diff] [blame]

4191

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4192

{

4193

fStatus = FALSE;

4194

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

4195

}

4196

Jeff Johnson

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

[diff] [blame]

4197

#ifdef WLAN_FEATURE_11AC

4198

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

4199

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

4200

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

4201

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

4202

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

4203

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

4209

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

Jeff Johnson

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

[diff] [blame]

4210

Kiran Kumar Lokere

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

[diff] [blame]

4211

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

Jeff Johnson

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

[diff] [blame]

4212

temp, NULL, eANI_BOOLEAN_FALSE)

4213

==eHAL_STATUS_FAILURE)

4214

{

4215

fStatus = FALSE;

4216

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

4217

}

4218

4219

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

Kiran Kumar Lokere

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

[diff] [blame]

4220

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

Jeff Johnson

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

[diff] [blame]

4221

Kiran Kumar Lokere

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

[diff] [blame]

4222

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

4223

temp, NULL, eANI_BOOLEAN_FALSE)

4224

==eHAL_STATUS_FAILURE)

4225

{

4226

fStatus = FALSE;

4227

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

4228

}

4229

4230

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

Kiran Kumar Lokere

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

[diff] [blame]

4231

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

Jeff Johnson

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

[diff] [blame]

4232

Kiran Kumar Lokere

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

[diff] [blame]

4233

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

4234

temp, NULL, eANI_BOOLEAN_FALSE)

4235

==eHAL_STATUS_FAILURE)

4236

{

4237

fStatus = FALSE;

4238

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]

4244

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

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

4245

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4246

{

4247

fStatus = FALSE;

4248

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

4249

}

4250

Kiran Kumar Lokere

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

[diff] [blame]

4251

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

Pratik Bhalgat

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

[diff] [blame]

4252

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

4253

==eHAL_STATUS_FAILURE)

4254

{

4255

fStatus = FALSE;

4256

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

4257

}

4258

4259

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

4260

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

4261

Kiran Kumar Lokere

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

[diff] [blame]

4262

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

Pratik Bhalgat

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

[diff] [blame]

4263

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

4264

==eHAL_STATUS_FAILURE)

4265

{

4266

fStatus = FALSE;

4267

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

4268

}

4269

Kiran Kumar Lokere

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

[diff] [blame]

4270

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

Pratik Bhalgat

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

[diff] [blame]

4271

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

4272

==eHAL_STATUS_FAILURE)

4273

{

4274

fStatus = FALSE;

4275

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

4276

}

Gopichand Nakkala

976e325

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

[diff] [blame]

4277

4278

#ifdef WLAN_SOFTAP_VSTA_FEATURE

4279

if(pConfig->fEnableVSTASupport)

4280

{

4281

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

4282

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

4283

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

4288

}

Kiran Kumar Lokere

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

[diff] [blame]

4289

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

Gopichand Nakkala

976e325

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

[diff] [blame]

4290

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4291

{

4292

fStatus = FALSE;

4293

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

4294

}

4295

#endif

Kiran Kumar Lokere

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

[diff] [blame]

4296

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

4297

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

4298

==eHAL_STATUS_FAILURE)

4299

{

4300

fStatus = FALSE;

4301

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

4302

}

Pratik Bhalgat

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

[diff] [blame]

4303

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

4304

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

4305

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4306

{

4307

fStatus = FALSE;

4308

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

4309

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

4310

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

4311

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4312

{

4313

fStatus = FALSE;

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

4314

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]

4315

}

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

4316

4317

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

4318

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4319

{

4320

fStatus = FALSE;

4321

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

4322

}

4323

4324

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

4325

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4326

{

4327

fStatus = FALSE;

4328

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

4329

}

4330

4331

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

4332

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4333

{

4334

fStatus = FALSE;

4335

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

4336

}

4337

Gopichand Nakkala

42bc89e

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

[diff] [blame]

4338

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

4339

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4340

{

4341

fStatus = FALSE;

4342

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

4343

}

4344

Gopichand Nakkala

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

[diff] [blame]

4345

#ifdef FEATURE_WLAN_TDLS

4346

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4347

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,

4348

pConfig->fTDLSUapsdMask, NULL,

4349

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4350

{

4351

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4352

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]

4353

}

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4354

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_BUF_STA_ENABLED,

4355

pConfig->fEnableTDLSBufferSta, NULL,

4356

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4357

{

4358

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4359

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]

4360

}

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4361

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_PUAPSD_INACT_TIME,

4362

pConfig->fTDLSPuapsdInactivityTimer, NULL,

4363

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4364

{

4365

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4366

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]

4367

}

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4368

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,

4369

pConfig->fTDLSRxFrameThreshold, NULL,

4370

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

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

[diff] [blame]

4371

{

4372

fStatus = FALSE;

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4373

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]

4374

}

4375

#endif

4376

Sudhir Sattayappa Kohalli

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

[diff] [blame]

4377

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,

4378

pConfig->fEnableAdaptRxDrain, NULL,

4379

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4380

{

4381

fStatus = FALSE;

4382

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

4383

}

Yue Ma

0fd2387

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

[diff] [blame]

4384

4385

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_FLEX_CONNECT_POWER_FACTOR,

4386

pConfig->flexConnectPowerFactor, NULL,

4387

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4388

{

4389

fStatus = FALSE;

4390

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

4391

"WNI_CFG_FLEX_CONNECT_POWER_FACTOR to CCM");

4392

}

4393

Madan Mohan Koyyalamudi

ca45457

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

[diff] [blame]

4394

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ANTENNA_DIVESITY,

4395

pConfig->antennaDiversity, NULL,

4396

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4397

{

4398

fStatus = FALSE;

4399

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

4400

}

4401

Kiet Lam

4bbd3cb

2013-11-07 20:03:49 +0530

[diff] [blame]

4402

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ATH_DISABLE,

4403

pConfig->cfgAthDisable, NULL,

4404

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

4405

{

4406

fStatus = FALSE;

4407

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

4408

}

c_hpothu

6d7dc92

2013-12-02 12:36:41 +0530

[diff] [blame^]

4409

4410

if (ccmCfgSetInt(pHddCtx->hHal,

4411

WNI_CFG_BTC_ACTIVE_WLAN_LEN,

4412

pConfig->cfgBtcActiveWlanLen,

4413

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4414

{

4415

fStatus = FALSE;

4416

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

4417

}

4418

4419

if (ccmCfgSetInt(pHddCtx->hHal,

4420

WNI_CFG_BTC_ACTIVE_BT_LEN,

4421

pConfig->cfgBtcActiveBtLen,

4422

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4423

{

4424

fStatus = FALSE;

4425

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

4426

}

4427

4428

if (ccmCfgSetInt(pHddCtx->hHal,

4429

WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,

4430

pConfig->cfgBtcSapActiveWlanLen,

4431

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4432

{

4433

fStatus = FALSE;

4434

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

4435

}

4436

4437

if (ccmCfgSetInt(pHddCtx->hHal,

4438

WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,

4439

pConfig->cfgBtcSapActiveBtLen,

4440

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

4441

{

4442

fStatus = FALSE;

4443

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

4444

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

4450

Kiran Kumar Lokere

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

[diff] [blame]

4451

\brief hdd_init_set_sme_config() -

Jeff Johnson

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

[diff] [blame]

4452

4453

This function initializes the sme configuration parameters

Kiran Kumar Lokere

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

[diff] [blame]

4454

Jeff Johnson

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

[diff] [blame]

4455

\param - pHddCtx - Pointer to the HDD Adapter.

Kiran Kumar Lokere

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

[diff] [blame]

4456

Jeff Johnson

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

[diff] [blame]

4457

\return - 0 for success, non zero for failure

Kiran Kumar Lokere

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

[diff] [blame]

4458

Jeff Johnson

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

[diff] [blame]

4459

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

4460

4461

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

4462

{

4463

VOS_STATUS status = VOS_STATUS_SUCCESS;

4464

eHalStatus halStatus;

4465

tSmeConfigParams smeConfig;

4466

4467

hdd_config_t *pConfig = pHddCtx->cfg_ini;

4468

Amar Singhal

fddc28c

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

[diff] [blame]

4469

Jeff Johnson

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

[diff] [blame]

4470

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

4471

Kiran Kumar Lokere

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

[diff] [blame]

4472

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

Jeff Johnson

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

[diff] [blame]

4473

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

4474

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

4475

4476

// Config params obtained from the registry

Amar Singhal

fddc28c

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

[diff] [blame]

4477

Jeff Johnson

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

[diff] [blame]

4478

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

4479

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

4480

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

4481

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

4482

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

4483

4484

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

4485

Leela Venkata Kiran Kumar Reddy Chirala

784d7e8

2013-11-20 10:57:25 -0800

[diff] [blame]

4486

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

4487

(pConfig->dot11Mode == eHDD_DOT11_MODE_11b) ||

4488

(pConfig->dot11Mode == eHDD_DOT11_MODE_11g) ||

4489

(pConfig->dot11Mode == eHDD_DOT11_MODE_11b_ONLY) ||

4490

(pConfig->dot11Mode == eHDD_DOT11_MODE_11g_ONLY))

4491

{

4492

smeConfig.csrConfig.channelBondingMode24GHz = 0;

4493

smeConfig.csrConfig.channelBondingMode5GHz = 0;

}

else

{

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

4498

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

4499

}

Jeff Johnson

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

[diff] [blame]

4500

smeConfig.csrConfig.TxRate = pConfig->TxRate;

4501

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

4502

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

4503

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

4504

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

4505

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

4506

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

4507

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

4508

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

4509

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

4510

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

4511

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

4512

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

4513

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

4514

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

Kiran Kumar Lokere

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

[diff] [blame]

4515

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

Jeff Johnson

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

[diff] [blame]

4516

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

4517

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

4518

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

4519

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Kiran Kumar Lokere

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

[diff] [blame]

4520

smeConfig.csrConfig.nActiveMaxChnTimeBtc = pConfig->nActiveMaxChnTimeBtc;

4521

smeConfig.csrConfig.nActiveMinChnTimeBtc = pConfig->nActiveMinChnTimeBtc;

Kiran Kumar Lokere

458d732

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

[diff] [blame]

4522

smeConfig.csrConfig.disableAggWithBtc = pConfig->disableAggWithBtc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

4523

#ifdef WLAN_AP_STA_CONCURRENCY

4524

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

4525

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

4526

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

4527

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

4528

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Sudhir Sattayappa Kohalli

eb97d50

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

[diff] [blame]

4529

smeConfig.csrConfig.nNumStaChanCombinedConc = pConfig->nNumStaChanCombinedConc;

4530

smeConfig.csrConfig.nNumP2PChanCombinedConc = pConfig->nNumP2PChanCombinedConc;

4531

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

4532

#endif

Jeff Johnson

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

[diff] [blame]

4533

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

4534

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

4535

4536

#if defined WLAN_FEATURE_VOWIFI

4537

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

4538

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

4539

#endif

4540

//Remaining config params not obtained from registry

4541

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

4542

#ifdef WLAN_FEATURE_11AC

4543

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

4544

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

4545

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Ravi Joshi

83bfaa1

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

[diff] [blame]

4546

smeConfig.csrConfig.enableVhtFor24GHz = pConfig->enableVhtFor24GHzBand;

Jeff Johnson

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

[diff] [blame]

4547

#endif

Shailender Karmuchi

a734f33

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

[diff] [blame]

4548

smeConfig.csrConfig.AdHocChannel5G = pConfig->AdHocChannel5G;

4549

smeConfig.csrConfig.AdHocChannel24 = pConfig->AdHocChannel24G;

Kiran Kumar Lokere

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

[diff] [blame]

4550

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

4551

smeConfig.csrConfig.HeartbeatThresh50 = 40;

4552

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

4553

if (pConfig->nBandCapability == eCSR_BAND_24)

4554

{

4555

smeConfig.csrConfig.Is11hSupportEnabled = 0;

4556

} else {

4557

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

4558

}

Kiran Kumar Lokere

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

[diff] [blame]

4559

smeConfig.csrConfig.cbChoice = 0;

4560

smeConfig.csrConfig.bgScanInterval = 0;

4561

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

Jeff Johnson

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

[diff] [blame]

4562

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

4563

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

4564

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

4565

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

4566

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

Srinivas Girigowda

bbd16eb

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

[diff] [blame]

4567

smeConfig.csrConfig.nRoamIntraBand = pConfig->nRoamIntraBand;

Varun Reddy Yeturu

920df21

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

[diff] [blame]

4568

smeConfig.csrConfig.nProbes = pConfig->nProbes;

Srinivas Girigowda

6cf0b82

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

[diff] [blame]

4569

4570

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

4571

{

4572

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,

4573

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

4574

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

4575

__func__, pConfig->nRoamScanHomeAwayTime,

4576

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

4577

pConfig->nRoamScanHomeAwayTime = 0;

4578

}

Varun Reddy Yeturu

920df21

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

[diff] [blame]

4579

smeConfig.csrConfig.nRoamScanHomeAwayTime = pConfig->nRoamScanHomeAwayTime;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

4580

#endif

Jeff Johnson

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

[diff] [blame]

4581

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

4582

Jeff Johnson

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

[diff] [blame]

4583

//FIXME 11d config is hardcoded

Jeff Johnson

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

[diff] [blame]

4584

if ( VOS_STA_SAP_MODE != hdd_get_conparam())

4585

{

4586

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

Jeff Johnson

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

[diff] [blame]

4587

Jeff Johnson

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

[diff] [blame]

4588

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

4589

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

4590

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

4591

* come from NV as per our current implementation */

Jeff Johnson

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

[diff] [blame]

4592

}

Jeff Johnson

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

[diff] [blame]

4593

else

4594

{

4595

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

4596

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

Jeff Johnson

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

[diff] [blame]

4597

Jeff Johnson

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

[diff] [blame]

4598

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

4599

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

4600

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

4601

}

Jeff Johnson

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

[diff] [blame]

4602

hdd_set_power_save_config(pHddCtx, &smeConfig);

4603

hdd_set_btc_config(pHddCtx);

4604

Kiran Kumar Lokere

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

[diff] [blame]

4605

#ifdef WLAN_FEATURE_VOWIFI_11R

Jeff Johnson

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

[diff] [blame]

4606

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

4607

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4608

#ifdef FEATURE_WLAN_LFR

4609

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Sameer Thalappil

4ae66ec

2013-11-05 14:17:35 -0800

[diff] [blame]

4610

smeConfig.csrConfig.MAWCEnabled = pConfig->MAWCEnabled;

Jeff Johnson

04dd8a8

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

[diff] [blame]

4611

#endif

Jeff Johnson

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

[diff] [blame]

4612

#ifdef FEATURE_WLAN_CCX

4613

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

4614

if( pConfig->isCcxIniFeatureEnabled )

4615

{

4616

pConfig->isFastTransitionEnabled = TRUE;

4617

}

Jeff Johnson

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

[diff] [blame]

4618

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4619

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

4620

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Srinivas Girigowda

41c7c5f

2013-10-21 19:01:38 -0700

[diff] [blame]

4621

if (pConfig->nSelect5GHzMargin)

4622

{

4623

pConfig->RoamRssiDiff = 0;

4624

}

Jeff Johnson

43971f5

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

[diff] [blame]

4625

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

4626

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Srinivas Girigowda

ad34ca9

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

[diff] [blame]

4627

smeConfig.csrConfig.isWESModeEnabled = pConfig->isWESModeEnabled;

Jeff Johnson

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

[diff] [blame]

4628

#endif

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4629

#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD

4630

smeConfig.csrConfig.isRoamOffloadScanEnabled = pConfig->isRoamOffloadScanEnabled;

Srinivas Girigowda

830bbd0

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

[diff] [blame]

4631

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = pConfig->bFastRoamInConIniFeatureEnabled;

4632

4633

if (0 == smeConfig.csrConfig.isRoamOffloadScanEnabled)

4634

{

4635

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

4636

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = 0;

4637

}

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4638

#endif

Jeff Johnson

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

[diff] [blame]

4639

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

4640

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

4641

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

Kiran Kumar Lokere

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

[diff] [blame]

4642

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

4643

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

Jeff Johnson

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

[diff] [blame]

4644

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

Kiran Kumar Lokere

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

[diff] [blame]

4645

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

Jeff Johnson

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

[diff] [blame]

4646

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

Srinivas Girigowda

de69741

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

[diff] [blame]

4647

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

Kiran Kumar Lokere

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

[diff] [blame]

4648

hdd_string_to_u8_array( pConfig->neighborScanChanList,

4649

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

4650

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

Jeff Johnson

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

[diff] [blame]

4651

WNI_CFG_VALID_CHANNEL_LIST_LEN );

4652

#endif

4653

4654

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

4655

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

4656

Kiran Kumar Lokere

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

[diff] [blame]

4657

//Enable/Disable MCC

Jeff Johnson

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

[diff] [blame]

4658

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

4659

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

4660

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

4661

//Scan Results Aging Time out value

4662

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

4663

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

4664

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

4665

krunal soni

5afa96c

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

[diff] [blame]

4666

smeConfig.csrConfig.isAmsduSupportInAMPDU = pConfig->isAmsduSupportInAMPDU;

Srinivas Girigowda

41c7c5f

2013-10-21 19:01:38 -0700

[diff] [blame]

4667

smeConfig.csrConfig.nSelect5GHzMargin = pConfig->nSelect5GHzMargin;

krunal soni

5afa96c

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

[diff] [blame]

4668

krunal soni

e9002db

2013-11-25 14:24:17 -0800

[diff] [blame]

4669

smeConfig.csrConfig.isCoalesingInIBSSAllowed =

4670

pHddCtx->cfg_ini->isCoalesingInIBSSAllowed;

4671

4672

Gopichand Nakkala

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

[diff] [blame]

4673

/* update SSR config */

4674

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

Gopichand Nakkala

86e4266

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

[diff] [blame]

4675

/* Update the Directed scan offload setting */

4676

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

Gopichand Nakkala

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

[diff] [blame]

4677

Kiran Kumar Lokere

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

[diff] [blame]

4678

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

Jeff Johnson

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

[diff] [blame]

4679

if ( !HAL_STATUS_SUCCESS( halStatus ) )

4680

{

4681

status = VOS_STATUS_E_FAILURE;

4682

}

4683

Kiran Kumar Lokere

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

[diff] [blame]

4684

4685

return status;

Jeff Johnson

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

[diff] [blame]

}

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

4690

4691

\brief hdd_execute_config_command() -

4692

4693

This function executes an arbitrary configuration set command

4694

4695

\param - pHddCtx - Pointer to the HDD Adapter.

4696

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

4697

4698

4699

\return - 0 for success, non zero for failure

4700

4701

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

4702

4703

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

4704

{

4705

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

4706

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;

4715

unsigned int idx;

4716

unsigned int i;

4717

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

4718

int rv;

Jeff Johnson

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

[diff] [blame]

4719

4720

// assume failure until proven otherwise

4721

vstatus = VOS_STATUS_E_FAILURE;

4722

4723

// clone the command so that we can manipulate it

4724

clone = kstrdup(command, GFP_ATOMIC);

4725

if (NULL == clone)

4726

{

4727

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4728

__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

4733

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

4734

pCmd = clone;

4735

4736

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

4742

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

4747

name = pCmd;

4748

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]

4756

__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

4766

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4767

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

4772

if ('\0' == *value_str)

4773

{

4774

// did not find a value

4775

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4776

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

4781

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

4782

{

4783

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

{

// found a match

break;

}

}

if (tableSize == idx)

4790

{

4791

// did not match the name

4792

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4793

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

4798

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

4799

{

4800

// does not support dynamic configuration

4801

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4802

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

4807

4808

switch (pRegEntry->RegType)

4809

{

4810

case WLAN_PARAM_Integer:

Jeff Johnson

2013-10-26 19:17:13 -0700

[diff] [blame]

4811

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4812

if (rv < 0)

4813

goto done;

Jeff Johnson

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

[diff] [blame]

4814

if (value < pRegEntry->VarMin)

4815

{

4816

// out of range

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

4817

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4818

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4819

goto done;

4820

}

4821

if (value > pRegEntry->VarMax)

4822

{

4823

// out of range

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

4824

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4825

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4826

goto done;

4827

}

4828

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

4829

break;

4830

4831

case WLAN_PARAM_HexInteger:

Jeff Johnson

2013-10-26 19:17:13 -0700

[diff] [blame]

4832

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4833

if (rv < 0)

4834

goto done;

Jeff Johnson

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

[diff] [blame]

4835

if (value < pRegEntry->VarMin)

4836

{

4837

// out of range

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

4838

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4839

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4840

goto done;

4841

}

4842

if (value > pRegEntry->VarMax)

4843

{

4844

// out of range

Jeff Johnson

2013-10-30 12:37:43 -0700

[diff] [blame]

4845

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4846

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4847

goto done;

4848

}

4849

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

4850

break;

4851

4852

case WLAN_PARAM_SignedInteger:

Jeff Johnson

2013-10-26 19:17:13 -0700

[diff] [blame]

4853

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4854

if (rv < 0)

4855

goto done;

Jeff Johnson

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

[diff] [blame]

4856

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

4857

{

4858

// out of range

4859

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4860

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

Jeff Johnson

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

[diff] [blame]

4861

goto done;

4862

}

4863

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

4864

{

4865

// out of range

4866

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4867

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

Jeff Johnson

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

[diff] [blame]

4868

goto done;

4869

}

4870

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

4871

break;

4872

4873

case WLAN_PARAM_String:

4874

len_value_str = strlen(value_str);

4875

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

{

// too big

hddLog(LOGE,

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

4880

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4881

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

4882

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

4883

goto done;

4884

}

4885

// copy string plus NUL

4886

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

4887

break;

4888

4889

case WLAN_PARAM_MacAddr:

4890

len_value_str = strlen(value_str);

4891

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

4896

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4897

__func__, value_str,

Jeff Johnson