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

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

[diff] [blame]

2152

#ifdef WLAN_FEATURE_11AC

2153

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

2154

#endif

2155

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

2156

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

2157

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

Madan Mohan Koyyalamudi

3f65e31

2012-11-06 15:31:12 -0800

[diff] [blame]

2158

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

Pratik Bhalgat

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

[diff] [blame]

2159

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]

2160

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

Jeff Johnson

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

[diff] [blame]

}

#define CFG_VALUE_MAX_LEN 256

2165

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2166

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

2167

{

2168

unsigned int idx;

2169

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2170

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

2171

v_U32_t value;

2172

char valueStr[CFG_VALUE_MAX_LEN];

2173

char configStr[CFG_ENTRY_MAX_LEN];

2174

char *fmt;

2175

void *pField;

2176

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2181

*pCur = '\0';

2182

2183

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

2184

{

2185

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

2186

2187

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

2188

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2189

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2190

{

2191

value = 0;

2192

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

2193

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

2206

}

2207

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2208

{

2209

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

2210

}

2211

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2212

{

2213

pMacAddr = (v_MACADDR_t *) pField;

2214

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2215

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

2226

}

2227

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2232

"*" : "");

2233

2234

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

2235

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

2236

#ifdef RETURN_IN_BUFFER

2237

if (curlen <= buflen)

2238

{

2239

// copy string + '\0'

2240

memcpy(pCur, configStr, curlen+1);

2241

2242

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2249

return VOS_STATUS_E_RESOURCES;

2250

}

2251

#else

2252

printk(KERN_CRIT "%s", configStr);

2253

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2258

// notify application that output is in system log

2259

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

2260

#endif // RETURN_IN_BUFFER

2261

2262

return VOS_STATUS_SUCCESS;

2263

}

2264

2265

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

2266

char *name, char** value)

2267

{

2268

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2269

unsigned long i;

2270

2271

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

2272

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

2273

*value = iniTable[i].value;

2274

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

2275

WLAN_INI_FILE, name, *value);

2276

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2284

{

2285

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

2286

return c-'0';

2287

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

2288

return c-'a'+10;

2289

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)

2297

{

2298

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2299

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2300

unsigned int idx;

2301

void *pField;

2302

char *value_str = NULL;

2303

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2308

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2309

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

2310

v_U32_t cbOutString;

2311

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2312

int rv;

Jeff Johnson

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

[diff] [blame]

2313

2314

// sanity test

2315

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2316

{

2317

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2318

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2319

}

2320

2321

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

2322

{

2323

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

2324

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

2325

2326

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

2327

2328

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

2329

{

2330

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

2331

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2332

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2333

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2338

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2339

{

2340

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

2341

// If not, use the default value.

2342

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2343

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

2344

if (rv < 0) {

2345

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

2346

__func__, pRegEntry->RegName);

2347

value = pRegEntry->VarDefault;

2348

}

Jeff Johnson

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

[diff] [blame]

2349

}

2350

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2351

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

2352

if (rv < 0) {

2353

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

2354

__func__, pRegEntry->RegName);

2355

value = pRegEntry->VarDefault;

2356

}

Jeff Johnson

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

[diff] [blame]

2357

}

2358

else {

2359

value = pRegEntry->VarDefault;

2360

}

2361

2362

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

2363

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2364

{

2365

if ( value > pRegEntry->VarMax )

2366

{

2367

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2368

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

Jeff Johnson

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

[diff] [blame]

2369

value = pRegEntry->VarMax;

2370

}

2371

2372

if ( value < pRegEntry->VarMin )

2373

{

2374

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2375

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

Jeff Johnson

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

[diff] [blame]

2376

value = pRegEntry->VarMin;

2377

}

2378

}

2379

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

2380

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2381

{

2382

if ( value > pRegEntry->VarMax )

2383

{

2384

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2385

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

Jeff Johnson

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

[diff] [blame]

2386

value = pRegEntry->VarDefault;

2387

}

2388

2389

if ( value < pRegEntry->VarMin )

2390

{

2391

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2392

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

Jeff Johnson

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

[diff] [blame]

2393

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2398

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

2399

}

2400

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2401

{

2402

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

2403

// If not, use the default value.

2404

if (VOS_STATUS_SUCCESS == match_status)

2405

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2406

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

2407

if (rv < 0) {

2408

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

2409

__func__, pRegEntry->RegName);

2410

svalue = (v_S31_t)pRegEntry->VarDefault;

2411

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2416

}

2417

2418

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

2419

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2420

{

2421

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

2422

{

2423

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2424

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

Jeff Johnson

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

[diff] [blame]

2425

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

2426

svalue = (v_S31_t)pRegEntry->VarMax;

2427

}

2428

2429

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

2430

{

2431

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2432

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

Jeff Johnson

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

[diff] [blame]

2433

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

2434

svalue = (v_S31_t)pRegEntry->VarMin;

2435

}

2436

}

2437

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

2438

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2439

{

2440

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

2441

{

2442

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

2443

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2444

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2445

(int)pRegEntry->VarMax,

2446

(int)pRegEntry->VarDefault );

2447

svalue = (v_S31_t)pRegEntry->VarDefault;

2448

}

2449

2450

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

2451

{

2452

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

2453

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2454

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2455

(int)pRegEntry->VarMin,

2456

(int)pRegEntry->VarDefault);

2457

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2462

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

2463

}

2464

// Handle string parameters

2465

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2466

{

2467

#ifdef WLAN_CFG_DEBUG

2468

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

2469

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

2470

#endif

2471

2472

if ( match_status == VOS_STATUS_SUCCESS)

2473

{

2474

len_value_str = strlen(value_str);

2475

2476

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

2477

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]

2478

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

Jeff Johnson

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

[diff] [blame]

2479

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

2480

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

2481

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

}

else

{

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

2486

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

}

}

else

{

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

2492

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

2493

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

2494

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

2495

}

2496

}

2497

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2498

{

2499

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2500

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2501

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

Jeff Johnson

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

[diff] [blame]

2502

continue;

2503

}

2504

candidate = (char*)pRegEntry->VarDefault;

2505

if ( match_status == VOS_STATUS_SUCCESS) {

2506

len_value_str = strlen(value_str);

2507

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

2508

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]

2509

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

Jeff Johnson

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

[diff] [blame]

2510

}

2511

else

2512

candidate = value_str;

2513

}

2514

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

2515

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

2516

{

2517

((char*)pField)[i] =

2518

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

}

}

else

{

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]

2524

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2525

}

2526

2527

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

2528

if( (match_status == VOS_STATUS_SUCCESS) &&

2529

(idx < MAX_CFG_INI_ITEMS) )

2530

{

2531

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

}

}

print_hdd_cfg(pHddCtx);

2536

2537

return( ret_status );

2538

}

2539

2540

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2545

return eCSR_DOT11_MODE_abg;

2546

case (eHDD_DOT11_MODE_11b):

2547

return eCSR_DOT11_MODE_11b;

2548

case (eHDD_DOT11_MODE_11g):

2549

return eCSR_DOT11_MODE_11g;

2550

default:

2551

case (eHDD_DOT11_MODE_11n):

2552

return eCSR_DOT11_MODE_11n;

2553

case (eHDD_DOT11_MODE_11g_ONLY):

2554

return eCSR_DOT11_MODE_11g_ONLY;

2555

case (eHDD_DOT11_MODE_11n_ONLY):

2556

return eCSR_DOT11_MODE_11n_ONLY;

2557

case (eHDD_DOT11_MODE_11b_ONLY):

2558

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2559

#ifdef WLAN_FEATURE_11AC

2560

case (eHDD_DOT11_MODE_11ac_ONLY):

2561

return eCSR_DOT11_MODE_11ac_ONLY;

2562

case (eHDD_DOT11_MODE_11ac):

2563

return eCSR_DOT11_MODE_11ac;

2564

#endif

Jeff Johnson

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

[diff] [blame]

2565

case (eHDD_DOT11_MODE_AUTO):

2566

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2572

{

2573

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2574

tSmeBtcConfig btcParams;

2575

2576

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2577

2578

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2579

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2580

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2581

Jeff Johnson

32d95a3

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

[diff] [blame]

2582

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2583

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2584

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2585

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2586

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2587

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2588

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2589

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2590

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2591

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2592

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2593

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2594

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2595

Jeff Johnson

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

[diff] [blame]

2596

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2597

}

2598

2599

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

2600

{

2601

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2602

2603

tPmcBmpsConfigParams bmpsParams;

2604

2605

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

2606

2607

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

2608

{

2609

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

2610

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2611

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2612

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2613

}

2614

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

2615

{

2616

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

2617

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2618

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2619

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2620

}

2621

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

2622

{

2623

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

2624

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2625

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2626

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2627

}

2628

2629

if (pConfig->fIsImpsEnabled)

2630

{

2631

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2636

}

2637

2638

if (pConfig->fIsBmpsEnabled)

2639

{

2640

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2645

}

2646

2647

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2648

2649

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

2650

{

2651

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

2652

}

2653

2654

if(pConfig->fIsAutoBmpsTimerEnabled)

2655

{

2656

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2662

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 )

2667

{

2668

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2672

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

2673

{

2674

int val;

2675

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

2676

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

2677

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

2678

{

2679

intArray[*len] = (tANI_U8) val;

2680

*len += 1;

2681

}

2682

s = strpbrk( s, "," );

2683

if( s )

2684

s++;

2685

}

Jeff Johnson

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

[diff] [blame]

2686

2687

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2694

{

2695

v_BOOL_t fStatus = TRUE;

2696

2697

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2698

tSirMacHTCapabilityInfo htCapInfo;

2699

Jeff Johnson

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

[diff] [blame]

2700

2701

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2702

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

2703

{

2704

fStatus = FALSE;

2705

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

2706

}

2707

2708

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

2709

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2710

{

2711

fStatus = FALSE;

2712

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

2713

}

2714

2715

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

2716

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2717

{

2718

fStatus = FALSE;

2719

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

2720

}

2721

2722

if ( 0 != pConfig->Cfg1Id )

2723

{

2724

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

2725

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2726

{

2727

fStatus = FALSE;

2728

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

}

}

if ( 0 != pConfig->Cfg2Id )

2734

{

2735

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

2736

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2737

{

2738

fStatus = FALSE;

2739

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

}

}

if ( 0 != pConfig->Cfg3Id )

2744

{

2745

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

2746

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2747

{

2748

fStatus = FALSE;

2749

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

}

}

if ( 0 != pConfig->Cfg4Id )

2754

{

2755

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

2756

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2757

{

2758

fStatus = FALSE;

2759

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

}

}

if ( 0 != pConfig->Cfg5Id )

2764

{

2765

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

2766

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2767

{

2768

fStatus = FALSE;

2769

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

}

}

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

2774

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2775

{

2776

fStatus = FALSE;

2777

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

2778

}

2779

2780

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

2781

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2782

{

2783

fStatus = FALSE;

2784

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

2785

}

2786

2787

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2788

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

2789

{

2790

fStatus = FALSE;

2791

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

2792

}

2793

2794

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

2795

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2796

{

2797

fStatus = FALSE;

2798

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

2799

}

2800

2801

if (pConfig->fIsAutoIbssBssid)

2802

{

2803

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

2804

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

2805

{

2806

fStatus = FALSE;

2807

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

}

}

else

{

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

2813

{

2814

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2815

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

2816

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

2817

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

2818

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

2819

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

2820

{

2821

fStatus = FALSE;

2822

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

}

}

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

2833

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2834

{

2835

fStatus = FALSE;

2836

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

2837

}

2838

2839

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

2840

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2841

{

2842

fStatus = FALSE;

2843

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

2844

}

2845

2846

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

2847

{

2848

fStatus = FALSE;

2849

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

2850

}

2851

2852

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

2853

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2854

{

2855

fStatus = FALSE;

2856

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

2857

}

2858

2859

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

2860

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2861

{

2862

fStatus = FALSE;

2863

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

2864

}

2865

Jeff Johnson

04dd8a8

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

[diff] [blame]

2866

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

2867

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_FT_RSSI_FILTER_PERIOD, pConfig->FTRssiFilterPeriod,

2868

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2869

{

2870

fStatus = FALSE;

2871

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

}

#endif

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

2876

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2877

{

2878

fStatus = FALSE;

2879

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

2880

}

2881

2882

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

2883

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2884

{

2885

fStatus = FALSE;

2886

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

2887

}

2888

2889

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

2890

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2891

{

2892

fStatus = FALSE;

2893

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

2894

}

2895

2896

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

2897

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2898

{

2899

fStatus = FALSE;

2900

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

2901

}

2902

2903

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

2904

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2905

{

2906

fStatus = FALSE;

2907

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

2908

}

2909

2910

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

2911

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2912

{

2913

fStatus = FALSE;

2914

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

2915

}

2916

2917

#ifdef WLAN_SOFTAP_FEATURE

2918

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

2919

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2920

{

2921

fStatus = FALSE;

2922

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

2923

}

2924

2925

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

2926

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2927

{

2928

fStatus = FALSE;

2929

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

2930

}

2931

Jeff Johnson

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

[diff] [blame]

2932

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

2933

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2934

{

2935

fStatus = FALSE;

2936

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

2937

}

2938

2939

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

2940

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2941

{

2942

fStatus = FALSE;

2943

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

2948

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

2949

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2950

{

2951

fStatus = FALSE;

2952

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

2953

}

2954

2955

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

2956

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2957

{

2958

fStatus = FALSE;

2959

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

2960

}

2961

2962

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

2963

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2964

{

2965

fStatus = FALSE;

2966

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

2967

}

2968

2969

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

2970

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2971

#endif

2972

2973

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

2974

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2975

{

2976

fStatus = FALSE;

2977

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

2978

}

2979

2980

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

2981

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2982

{

2983

fStatus = FALSE;

2984

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

2985

}

2986

2987

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

2988

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2989

{

2990

fStatus = FALSE;

2991

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

2992

}

2993

2994

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

2995

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2996

{

2997

fStatus = FALSE;

2998

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

2999

}

3000

3001

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

3002

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3003

{

3004

fStatus = FALSE;

3005

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

3006

}

3007

3008

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

3009

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3010

{

3011

fStatus = FALSE;

3012

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

3013

}

3014

3015

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

3016

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3017

{

3018

fStatus = FALSE;

3019

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

3020

}

3021

3022

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

3023

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3024

{

3025

fStatus = FALSE;

3026

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

3027

}

3028

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

3029

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3030

{

3031

fStatus = FALSE;

3032

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

3033

}

3034

3035

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

3036

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3037

{

3038

fStatus = FALSE;

3039

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

3040

}

3041

3042

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

3043

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3044

{

3045

fStatus = FALSE;

3046

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

3047

}

3048

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3049

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

3050

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3051

{

3052

fStatus = FALSE;

3053

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

3054

}

3055

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

3056

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3057

{

3058

fStatus = FALSE;

3059

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

3060

}

3061

3062

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

3063

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3064

{

3065

fStatus = FALSE;

3066

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

3067

}

3068

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

3069

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3070

{

3071

fStatus = FALSE;

3072

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

}

#endif

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

3077

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3078

{

3079

fStatus = FALSE;

3080

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

3081

}

3082

3083

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3084

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3085

==eHAL_STATUS_FAILURE)

3086

{

3087

fStatus = FALSE;

3088

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

3089

}

3090

3091

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3092

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3093

==eHAL_STATUS_FAILURE)

3094

{

3095

fStatus = FALSE;

3096

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

3097

}

3098

3099

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3100

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

3101

{

3102

fStatus = FALSE;

3103

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

3104

}

3105

Jeff Johnson

d13512a

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

[diff] [blame]

3106

3107

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

3108

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3109

{

3110

fStatus = FALSE;

3111

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

3112

}

3113

Jeff Johnson

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

[diff] [blame]

3114

#ifdef WLAN_FEATURE_11AC

3115

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

3116

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

3117

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

3118

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

3119

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3120

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3126

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

3127

3128

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3129

temp, NULL, eANI_BOOLEAN_FALSE)

3130

==eHAL_STATUS_FAILURE)

3131

{

3132

fStatus = FALSE;

3133

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

3134

}

3135

3136

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

3137

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

3138

3139

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3140

temp, NULL, eANI_BOOLEAN_FALSE)

3141

==eHAL_STATUS_FAILURE)

3142

{

3143

fStatus = FALSE;

3144

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

3145

}

3146

3147

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

3148

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

3149

3150

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3151

temp, NULL, eANI_BOOLEAN_FALSE)

3152

==eHAL_STATUS_FAILURE)

3153

{

3154

fStatus = FALSE;

3155

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

}

}

}

#endif

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

3161

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

3162

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3163

{

3164

fStatus = FALSE;

3165

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

3166

}

3167

Pratik Bhalgat

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

[diff] [blame]

3168

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3169

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3170

==eHAL_STATUS_FAILURE)

3171

{

3172

fStatus = FALSE;

3173

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

3174

}

3175

3176

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

3177

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3178

3179

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3180

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

3181

==eHAL_STATUS_FAILURE)

3182

{

3183

fStatus = FALSE;

3184

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

3185

}

3186

3187

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3188

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3189

==eHAL_STATUS_FAILURE)

3190

{

3191

fStatus = FALSE;

3192

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

3193

}

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3194

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3195

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3196

==eHAL_STATUS_FAILURE)

3197

{

3198

fStatus = FALSE;

3199

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

3200

}

Pratik Bhalgat

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

[diff] [blame]

3201

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3207

3208

\brief hdd_init_set_sme_config() -

3209

3210

This function initializes the sme configuration parameters

3211

3212

\param - pHddCtx - Pointer to the HDD Adapter.

3213

3214

\return - 0 for success, non zero for failure

3215

3216

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

3217

3218

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3219

{

3220

VOS_STATUS status = VOS_STATUS_SUCCESS;

3221

eHalStatus halStatus;

3222

tSmeConfigParams smeConfig;

3223

3224

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3225

3226

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3227

3228

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3229

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

3230

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

3231

3232

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3233

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3234

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

Jeff Johnson

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

[diff] [blame]

3235

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3236

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3237

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3238

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3239

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3240

3241

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

3242

3243

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3244

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3245

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3246

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3247

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3248

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3249

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3250

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3251

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3252

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3253

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3254

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3255

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3256

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3257

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3258

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3259

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3260

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3261

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3262

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3263

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3264

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3265

#ifdef WLAN_AP_STA_CONCURRENCY

3266

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3267

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3268

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3269

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3270

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

2012-12-17 13:04:30 -0800

[diff] [blame]

3271

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3272

#endif

Jeff Johnson

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

[diff] [blame]

3273

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3274

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3275

3276

#if defined WLAN_FEATURE_VOWIFI

3277

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3278

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3279

#endif

3280

//Remaining config params not obtained from registry

3281

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3282

#ifdef WLAN_FEATURE_11AC

3283

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3284

#endif

Jeff Johnson

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

[diff] [blame]

3285

smeConfig.csrConfig.AdHocChannel5G = 44;

3286

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3287

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3288

smeConfig.csrConfig.Is11hSupportEnabled = 1;

Jeff Johnson

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

[diff] [blame]

3289

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

3290

smeConfig.csrConfig.cbChoice = 0;

3291

smeConfig.csrConfig.bgScanInterval = 0;

3292

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3293

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3294

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3295

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

2012-11-06 15:31:12 -0800

[diff] [blame]

3296

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3297

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

3298

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3299

#endif

Jeff Johnson

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

[diff] [blame]

3300

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3301

Jeff Johnson

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

[diff] [blame]

3302

//FIXME 11d config is hardcoded

3303

#ifdef WLAN_SOFTAP_FEATURE

3304

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3305

#endif

3306

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

3307

3308

//if there is a requirement that HDD will control the default channel list &

3309

//country code (say from .ini file) we need to add some logic here. Otherwise

3310

//the default 11d info should come from NV as per our current implementation

3311

3312

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3317

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

3318

3319

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

3320

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

3321

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3322

}

3323

#endif

3324

hdd_set_power_save_config(pHddCtx, &smeConfig);

3325

hdd_set_btc_config(pHddCtx);

3326

3327

#ifdef WLAN_FEATURE_VOWIFI_11R

3328

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

3329

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3330

#ifdef FEATURE_WLAN_LFR

3331

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

3332

#endif

Jeff Johnson

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

[diff] [blame]

3333

#ifdef FEATURE_WLAN_CCX

3334

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

3335

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3336

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

3337

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3338

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3339

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3340

#endif

3341

3342

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3343

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

3344

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

3345

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

3346

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

3347

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

3348

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

3349

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

3350

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3351

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3352

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3353

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3354

#endif

3355

3356

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3357

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3358

3359

//Enable/Disable MCC

3360

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3361

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3362

Sandeep Puligilla

2b6dc63

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

[diff] [blame^]

3363

//Scan Results Aging Time out value

3364

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3365

Jeff Johnson

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

[diff] [blame]

3366

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

3367

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3368

{

3369

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3378

3379

\brief hdd_execute_config_command() -

3380

3381

This function executes an arbitrary configuration set command

3382

3383

\param - pHddCtx - Pointer to the HDD Adapter.

3384

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

3385

3386

3387

\return - 0 for success, non zero for failure

3388

3389

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

3390

3391

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3392

{

3393

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

3394

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;

3403

unsigned int idx;

3404

unsigned int i;

3405

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3406

int rv;

Jeff Johnson

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

[diff] [blame]

3407

3408

// assume failure until proven otherwise

3409

vstatus = VOS_STATUS_E_FAILURE;

3410

3411

// clone the command so that we can manipulate it

3412

clone = kstrdup(command, GFP_ATOMIC);

3413

if (NULL == clone)

3414

{

3415

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3416

__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

3421

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

3422

pCmd = clone;

3423

3424

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

3430

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3435

name = pCmd;

3436

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]

3444

__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

3454

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3455

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3460

if ('\0' == *value_str)

3461

{

3462

// did not find a value

3463

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3464

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3469

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

3470

{

3471

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

{

// found a match

break;

}

}

if (tableSize == idx)

3478

{

3479

// did not match the name

3480

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3481

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3486

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

3487

{

3488

// does not support dynamic configuration

3489

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3490

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

3495

3496

switch (pRegEntry->RegType)

3497

{

3498

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3499

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

3500

if (rv < 0)

3501

goto done;

Jeff Johnson

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

[diff] [blame]

3502

if (value < pRegEntry->VarMin)

3503

{

3504

// out of range

3505

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3506

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3507

goto done;

3508

}

3509

if (value > pRegEntry->VarMax)

3510

{

3511

// out of range

3512

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3513

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3514

goto done;

3515

}

3516

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

3517

break;

3518

3519

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3520

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

3521

if (rv < 0)

3522

goto done;

Jeff Johnson

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

[diff] [blame]

3523

if (value < pRegEntry->VarMin)

3524

{

3525

// out of range

3526

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3527

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3528

goto done;

3529

}

3530

if (value > pRegEntry->VarMax)

3531

{

3532

// out of range

3533

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3534

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3535

goto done;

3536

}

3537

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

3538

break;

3539

3540

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3541

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

3542

if (rv < 0)

3543

goto done;

Jeff Johnson

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

[diff] [blame]

3544

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

3545

{

3546

// out of range

3547

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3548

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

Jeff Johnson

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

[diff] [blame]

3549

goto done;

3550

}

3551

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

3552

{

3553

// out of range

3554

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3555

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

Jeff Johnson

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

[diff] [blame]

3556

goto done;

3557

}

3558

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

3559

break;

3560

3561

case WLAN_PARAM_String:

3562

len_value_str = strlen(value_str);

3563

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

{

// too big

hddLog(LOGE,

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

3568

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3569

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3570

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

3571

goto done;

3572

}

3573

// copy string plus NUL

3574

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

3575

break;

3576

3577

case WLAN_PARAM_MacAddr:

3578

len_value_str = strlen(value_str);

3579

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3584

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3585

__func__, value_str,

Jeff Johnson