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

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

[diff] [blame]

2212

#ifdef WLAN_FEATURE_11AC

2213

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

2214

#endif

2215

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

2216

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

2217

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]

2218

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]

2219

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]

2220

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

2225

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2226

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

2227

{

2228

unsigned int idx;

2229

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2230

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

2231

v_U32_t value;

2232

char valueStr[CFG_VALUE_MAX_LEN];

2233

char configStr[CFG_ENTRY_MAX_LEN];

2234

char *fmt;

2235

void *pField;

2236

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2241

*pCur = '\0';

2242

2243

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

2244

{

2245

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

2246

2247

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

2248

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2249

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2250

{

2251

value = 0;

2252

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

2253

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

2266

}

2267

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2268

{

2269

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

2270

}

2271

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2272

{

2273

pMacAddr = (v_MACADDR_t *) pField;

2274

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2275

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

2286

}

2287

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2292

"*" : "");

2293

2294

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

2295

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

2296

#ifdef RETURN_IN_BUFFER

2297

if (curlen <= buflen)

2298

{

2299

// copy string + '\0'

2300

memcpy(pCur, configStr, curlen+1);

2301

2302

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2309

return VOS_STATUS_E_RESOURCES;

2310

}

2311

#else

2312

printk(KERN_CRIT "%s", configStr);

2313

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2318

// notify application that output is in system log

2319

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

2320

#endif // RETURN_IN_BUFFER

2321

2322

return VOS_STATUS_SUCCESS;

2323

}

2324

2325

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

2326

char *name, char** value)

2327

{

2328

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2329

unsigned long i;

2330

2331

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

2332

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

2333

*value = iniTable[i].value;

2334

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

2335

WLAN_INI_FILE, name, *value);

2336

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2344

{

2345

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

2346

return c-'0';

2347

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

2348

return c-'a'+10;

2349

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)

2357

{

2358

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2359

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2360

unsigned int idx;

2361

void *pField;

2362

char *value_str = NULL;

2363

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2368

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2369

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

2370

v_U32_t cbOutString;

2371

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2372

int rv;

Jeff Johnson

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

[diff] [blame]

2373

2374

// sanity test

2375

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2376

{

2377

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]

2378

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2379

}

2380

2381

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

2382

{

2383

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

2384

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

2385

2386

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

2387

2388

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

2389

{

2390

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

2391

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2392

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2393

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2398

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2399

{

2400

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

2401

// If not, use the default value.

2402

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2403

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

2404

if (rv < 0) {

2405

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

2406

__func__, pRegEntry->RegName);

2407

value = pRegEntry->VarDefault;

2408

}

Jeff Johnson

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

[diff] [blame]

2409

}

2410

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2411

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

2412

if (rv < 0) {

2413

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

2414

__func__, pRegEntry->RegName);

2415

value = pRegEntry->VarDefault;

2416

}

Jeff Johnson

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

[diff] [blame]

2417

}

2418

else {

2419

value = pRegEntry->VarDefault;

2420

}

2421

2422

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

2423

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2424

{

2425

if ( value > pRegEntry->VarMax )

2426

{

2427

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2428

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

Jeff Johnson

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

[diff] [blame]

2429

value = pRegEntry->VarMax;

2430

}

2431

2432

if ( value < pRegEntry->VarMin )

2433

{

2434

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2435

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

Jeff Johnson

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

[diff] [blame]

2436

value = pRegEntry->VarMin;

2437

}

2438

}

2439

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

2440

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2441

{

2442

if ( value > pRegEntry->VarMax )

2443

{

2444

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]

2445

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

Jeff Johnson

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

[diff] [blame]

2446

value = pRegEntry->VarDefault;

2447

}

2448

2449

if ( value < pRegEntry->VarMin )

2450

{

2451

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]

2452

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

Jeff Johnson

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

[diff] [blame]

2453

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2458

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

2459

}

2460

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2461

{

2462

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

2463

// If not, use the default value.

2464

if (VOS_STATUS_SUCCESS == match_status)

2465

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2466

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

2467

if (rv < 0) {

2468

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

2469

__func__, pRegEntry->RegName);

2470

svalue = (v_S31_t)pRegEntry->VarDefault;

2471

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2476

}

2477

2478

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

2479

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2480

{

2481

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

2482

{

2483

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2484

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

Jeff Johnson

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

[diff] [blame]

2485

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

2486

svalue = (v_S31_t)pRegEntry->VarMax;

2487

}

2488

2489

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

2490

{

2491

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2492

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

Jeff Johnson

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

[diff] [blame]

2493

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

2494

svalue = (v_S31_t)pRegEntry->VarMin;

2495

}

2496

}

2497

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

2498

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2499

{

2500

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

2501

{

2502

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

2503

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2504

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2505

(int)pRegEntry->VarMax,

2506

(int)pRegEntry->VarDefault );

2507

svalue = (v_S31_t)pRegEntry->VarDefault;

2508

}

2509

2510

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

2511

{

2512

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

2513

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2514

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2515

(int)pRegEntry->VarMin,

2516

(int)pRegEntry->VarDefault);

2517

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2522

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

2523

}

2524

// Handle string parameters

2525

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2526

{

2527

#ifdef WLAN_CFG_DEBUG

2528

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

2529

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

2530

#endif

2531

2532

if ( match_status == VOS_STATUS_SUCCESS)

2533

{

2534

len_value_str = strlen(value_str);

2535

2536

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

2537

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]

2538

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

Jeff Johnson

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

[diff] [blame]

2539

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

2540

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

2541

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

}

else

{

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

2546

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

}

}

else

{

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

2552

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

2553

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

2554

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

2555

}

2556

}

2557

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2558

{

2559

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2560

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2561

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

Jeff Johnson

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

[diff] [blame]

2562

continue;

2563

}

2564

candidate = (char*)pRegEntry->VarDefault;

2565

if ( match_status == VOS_STATUS_SUCCESS) {

2566

len_value_str = strlen(value_str);

2567

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

2568

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]

2569

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

Jeff Johnson

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

[diff] [blame]

2570

}

2571

else

2572

candidate = value_str;

2573

}

2574

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

2575

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

2576

{

2577

((char*)pField)[i] =

2578

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

2584

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2585

}

2586

2587

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

2588

if( (match_status == VOS_STATUS_SUCCESS) &&

2589

(idx < MAX_CFG_INI_ITEMS) )

2590

{

2591

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

}

}

print_hdd_cfg(pHddCtx);

2596

2597

return( ret_status );

2598

}

2599

2600

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2605

return eCSR_DOT11_MODE_abg;

2606

case (eHDD_DOT11_MODE_11b):

2607

return eCSR_DOT11_MODE_11b;

2608

case (eHDD_DOT11_MODE_11g):

2609

return eCSR_DOT11_MODE_11g;

2610

default:

2611

case (eHDD_DOT11_MODE_11n):

2612

return eCSR_DOT11_MODE_11n;

2613

case (eHDD_DOT11_MODE_11g_ONLY):

2614

return eCSR_DOT11_MODE_11g_ONLY;

2615

case (eHDD_DOT11_MODE_11n_ONLY):

2616

return eCSR_DOT11_MODE_11n_ONLY;

2617

case (eHDD_DOT11_MODE_11b_ONLY):

2618

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2619

#ifdef WLAN_FEATURE_11AC

2620

case (eHDD_DOT11_MODE_11ac_ONLY):

2621

return eCSR_DOT11_MODE_11ac_ONLY;

2622

case (eHDD_DOT11_MODE_11ac):

2623

return eCSR_DOT11_MODE_11ac;

2624

#endif

Jeff Johnson

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

[diff] [blame]

2625

case (eHDD_DOT11_MODE_AUTO):

2626

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2632

{

2633

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2634

tSmeBtcConfig btcParams;

2635

2636

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2637

2638

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2639

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2640

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2641

Jeff Johnson

32d95a3

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

[diff] [blame]

2642

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2643

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2644

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2645

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2646

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2647

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2648

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2649

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2650

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2651

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2652

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2653

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2654

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2655

Jeff Johnson

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

[diff] [blame]

2656

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2657

}

2658

2659

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

2660

{

2661

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2662

2663

tPmcBmpsConfigParams bmpsParams;

2664

2665

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

2666

2667

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

2668

{

2669

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

2670

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2671

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2672

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2673

}

2674

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

2675

{

2676

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

2677

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2678

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2679

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2680

}

2681

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

2682

{

2683

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

2684

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2685

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2686

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2687

}

2688

2689

if (pConfig->fIsImpsEnabled)

2690

{

2691

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2696

}

2697

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame^]

2698

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

2699

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

2700

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

2701

Jeff Johnson

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

[diff] [blame]

2702

if (pConfig->fIsBmpsEnabled)

2703

{

2704

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2709

}

2710

2711

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2712

2713

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

2714

{

2715

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

2716

}

2717

2718

if(pConfig->fIsAutoBmpsTimerEnabled)

2719

{

2720

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2726

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 )

2731

{

2732

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2736

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

2737

{

2738

int val;

2739

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

2740

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

2741

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

2742

{

2743

intArray[*len] = (tANI_U8) val;

2744

*len += 1;

2745

}

2746

s = strpbrk( s, "," );

2747

if( s )

2748

s++;

2749

}

Jeff Johnson

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

[diff] [blame]

2750

2751

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2758

{

2759

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

2760

#ifdef WLAN_SOFTAP_VSTA_FEATURE

2761

tANI_U32 val;

2762

#endif

Jeff Johnson

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

[diff] [blame]

2763

2764

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2765

tSirMacHTCapabilityInfo htCapInfo;

2766

Jeff Johnson

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

[diff] [blame]

2767

2768

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2769

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

2770

{

2771

fStatus = FALSE;

2772

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

2773

}

2774

2775

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

2776

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2777

{

2778

fStatus = FALSE;

2779

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

2780

}

2781

2782

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

2783

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2784

{

2785

fStatus = FALSE;

2786

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

2787

}

2788

2789

if ( 0 != pConfig->Cfg1Id )

2790

{

2791

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

2792

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2793

{

2794

fStatus = FALSE;

2795

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

}

}

if ( 0 != pConfig->Cfg2Id )

2801

{

2802

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

2803

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2804

{

2805

fStatus = FALSE;

2806

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

}

}

if ( 0 != pConfig->Cfg3Id )

2811

{

2812

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

2813

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2814

{

2815

fStatus = FALSE;

2816

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

}

}

if ( 0 != pConfig->Cfg4Id )

2821

{

2822

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

2823

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2824

{

2825

fStatus = FALSE;

2826

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

}

}

if ( 0 != pConfig->Cfg5Id )

2831

{

2832

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

2833

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2834

{

2835

fStatus = FALSE;

2836

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

}

}

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

2841

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2842

{

2843

fStatus = FALSE;

2844

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

2845

}

2846

2847

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

2848

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2849

{

2850

fStatus = FALSE;

2851

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

2852

}

2853

2854

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2855

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

2856

{

2857

fStatus = FALSE;

2858

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

2859

}

2860

2861

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

2862

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2863

{

2864

fStatus = FALSE;

2865

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

2866

}

2867

2868

if (pConfig->fIsAutoIbssBssid)

2869

{

2870

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

2871

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

2872

{

2873

fStatus = FALSE;

2874

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

}

}

else

{

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

2880

{

2881

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2882

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

2883

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

2884

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

2885

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

2886

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

2887

{

2888

fStatus = FALSE;

2889

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,

2900

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2901

{

2902

fStatus = FALSE;

2903

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

2904

}

2905

2906

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

2907

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2908

{

2909

fStatus = FALSE;

2910

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

2911

}

2912

2913

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

2914

{

2915

fStatus = FALSE;

2916

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

2917

}

2918

2919

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

2920

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2921

{

2922

fStatus = FALSE;

2923

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

2924

}

2925

2926

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

2927

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2928

{

2929

fStatus = FALSE;

2930

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

2931

}

2932

Jeff Johnson

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

[diff] [blame]

2933

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

2934

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2935

{

2936

fStatus = FALSE;

2937

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

2938

}

2939

2940

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

2941

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2942

{

2943

fStatus = FALSE;

2944

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

2945

}

2946

2947

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

2948

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2949

{

2950

fStatus = FALSE;

2951

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

2952

}

2953

Gopichand Nakkala

98a98af

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

[diff] [blame]

2954

#ifdef FEATURE_WLAN_LFR

2955

if (pConfig->isFastRoamIniFeatureEnabled)

2956

{

2957

pConfig->fEnableFwRssiMonitoring = TRUE;

2958

}

2959

#endif

2960

#ifdef FEATURE_WLAN_CCX

2961

if (pConfig->isCcxIniFeatureEnabled)

2962

{

2963

pConfig->fEnableFwRssiMonitoring = TRUE;

2964

}

2965

#endif

Jeff Johnson

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

[diff] [blame]

2966

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

2967

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2968

{

2969

fStatus = FALSE;

2970

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

2971

}

2972

2973

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

2974

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2975

{

2976

fStatus = FALSE;

2977

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

2978

}

2979

2980

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

2981

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2982

{

2983

fStatus = FALSE;

2984

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

2985

}

2986

2987

#ifdef WLAN_SOFTAP_FEATURE

2988

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

2989

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2990

{

2991

fStatus = FALSE;

2992

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

2993

}

2994

2995

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

2996

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2997

{

2998

fStatus = FALSE;

2999

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

3000

}

3001

Jeff Johnson

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

[diff] [blame]

3002

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

3003

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3004

{

3005

fStatus = FALSE;

3006

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

3007

}

3008

3009

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

3010

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3011

{

3012

fStatus = FALSE;

3013

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

3018

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

3019

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3020

{

3021

fStatus = FALSE;

3022

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

3023

}

3024

3025

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

3026

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3027

{

3028

fStatus = FALSE;

3029

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

3030

}

3031

3032

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

3033

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3034

{

3035

fStatus = FALSE;

3036

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

3037

}

3038

3039

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

3040

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3041

#endif

3042

3043

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

3044

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3045

{

3046

fStatus = FALSE;

3047

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

3048

}

3049

3050

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

3051

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3052

{

3053

fStatus = FALSE;

3054

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

3055

}

3056

3057

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

3058

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3059

{

3060

fStatus = FALSE;

3061

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

3062

}

3063

3064

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

3065

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3066

{

3067

fStatus = FALSE;

3068

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

3069

}

3070

3071

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

3072

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3073

{

3074

fStatus = FALSE;

3075

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

3076

}

3077

3078

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

3079

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3080

{

3081

fStatus = FALSE;

3082

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

3083

}

3084

3085

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

3086

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3087

{

3088

fStatus = FALSE;

3089

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

3090

}

3091

3092

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

3093

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3094

{

3095

fStatus = FALSE;

3096

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

3097

}

3098

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

3099

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3100

{

3101

fStatus = FALSE;

3102

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

3103

}

3104

3105

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

3106

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3107

{

3108

fStatus = FALSE;

3109

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

3110

}

3111

3112

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

3113

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3114

{

3115

fStatus = FALSE;

3116

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

3117

}

3118

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3119

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

3120

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3121

{

3122

fStatus = FALSE;

3123

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

3124

}

3125

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

3126

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3127

{

3128

fStatus = FALSE;

3129

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

3130

}

3131

3132

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

3133

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3134

{

3135

fStatus = FALSE;

3136

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

3137

}

3138

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

3139

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3140

{

3141

fStatus = FALSE;

3142

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,

3147

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3148

{

3149

fStatus = FALSE;

3150

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

3151

}

3152

3153

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3154

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3155

==eHAL_STATUS_FAILURE)

3156

{

3157

fStatus = FALSE;

3158

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

3159

}

3160

3161

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3162

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3163

==eHAL_STATUS_FAILURE)

3164

{

3165

fStatus = FALSE;

3166

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

3167

}

3168

3169

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3170

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

3171

{

3172

fStatus = FALSE;

3173

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

3174

}

3175

Jeff Johnson

d13512a

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

[diff] [blame]

3176

3177

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

3178

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3179

{

3180

fStatus = FALSE;

3181

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

3182

}

3183

Jeff Johnson

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

[diff] [blame]

3184

#ifdef WLAN_FEATURE_11AC

3185

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

3186

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

3187

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

3188

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

3189

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3190

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3196

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

3197

3198

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3199

temp, NULL, eANI_BOOLEAN_FALSE)

3200

==eHAL_STATUS_FAILURE)

3201

{

3202

fStatus = FALSE;

3203

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

3204

}

3205

3206

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

3207

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

3208

3209

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3210

temp, NULL, eANI_BOOLEAN_FALSE)

3211

==eHAL_STATUS_FAILURE)

3212

{

3213

fStatus = FALSE;

3214

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

3215

}

3216

3217

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

3218

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

3219

3220

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3221

temp, NULL, eANI_BOOLEAN_FALSE)

3222

==eHAL_STATUS_FAILURE)

3223

{

3224

fStatus = FALSE;

3225

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]

3231

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

3232

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3233

{

3234

fStatus = FALSE;

3235

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

3236

}

3237

Pratik Bhalgat

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

[diff] [blame]

3238

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3239

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3240

==eHAL_STATUS_FAILURE)

3241

{

3242

fStatus = FALSE;

3243

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

3244

}

3245

3246

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

3247

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3248

3249

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3250

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

3251

==eHAL_STATUS_FAILURE)

3252

{

3253

fStatus = FALSE;

3254

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

3255

}

3256

3257

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3258

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3259

==eHAL_STATUS_FAILURE)

3260

{

3261

fStatus = FALSE;

3262

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

3263

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3264

3265

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3266

if(pConfig->fEnableVSTASupport)

3267

{

3268

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

3269

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3270

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3275

}

3276

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

3277

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3278

{

3279

fStatus = FALSE;

3280

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

3281

}

3282

#endif

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3283

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3284

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3285

==eHAL_STATUS_FAILURE)

3286

{

3287

fStatus = FALSE;

3288

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

3289

}

Pratik Bhalgat

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

[diff] [blame]

3290

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3291

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

3292

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3293

{

3294

fStatus = FALSE;

3295

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

3296

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3302

3303

\brief hdd_init_set_sme_config() -

3304

3305

This function initializes the sme configuration parameters

3306

3307

\param - pHddCtx - Pointer to the HDD Adapter.

3308

3309

\return - 0 for success, non zero for failure

3310

3311

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

3312

3313

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3314

{

3315

VOS_STATUS status = VOS_STATUS_SUCCESS;

3316

eHalStatus halStatus;

3317

tSmeConfigParams smeConfig;

3318

3319

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3320

3321

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3322

3323

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3324

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

3325

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

3326

3327

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3328

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3329

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

Jeff Johnson

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

[diff] [blame]

3330

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3331

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3332

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3333

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3334

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3335

3336

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

3337

3338

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3339

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3340

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3341

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3342

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3343

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3344

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3345

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3346

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3347

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3348

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3349

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3350

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3351

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3352

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3353

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3354

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3355

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3356

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3357

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3358

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3359

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3360

#ifdef WLAN_AP_STA_CONCURRENCY

3361

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3362

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3363

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3364

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3365

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

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

[diff] [blame]

3366

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3367

#endif

Jeff Johnson

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

[diff] [blame]

3368

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3369

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3370

3371

#if defined WLAN_FEATURE_VOWIFI

3372

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3373

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3374

#endif

3375

//Remaining config params not obtained from registry

3376

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3377

#ifdef WLAN_FEATURE_11AC

3378

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3379

#endif

Jeff Johnson

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

[diff] [blame]

3380

smeConfig.csrConfig.AdHocChannel5G = 44;

3381

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3382

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3383

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3384

if (pConfig->nBandCapability == eCSR_BAND_24)

3385

{

3386

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3387

} else {

3388

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3389

}

Jeff Johnson

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

[diff] [blame]

3390

smeConfig.csrConfig.cbChoice = 0;

3391

smeConfig.csrConfig.bgScanInterval = 0;

3392

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3393

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3394

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3395

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3396

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3397

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

3398

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3399

#endif

Jeff Johnson

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

[diff] [blame]

3400

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3401

Jeff Johnson

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

[diff] [blame]

3402

//FIXME 11d config is hardcoded

3403

#ifdef WLAN_SOFTAP_FEATURE

3404

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3405

#endif

3406

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

3407

3408

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

3409

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

3410

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

3411

3412

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3417

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

3418

3419

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

3420

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

3421

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3422

}

3423

#endif

3424

hdd_set_power_save_config(pHddCtx, &smeConfig);

3425

hdd_set_btc_config(pHddCtx);

3426

3427

#ifdef WLAN_FEATURE_VOWIFI_11R

3428

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

3429

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3430

#ifdef FEATURE_WLAN_LFR

3431

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3432

if( pConfig->isFastRoamIniFeatureEnabled )

3433

{

3434

pConfig->isFastTransitionEnabled = TRUE;

3435

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

3436

#endif

Jeff Johnson

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

[diff] [blame]

3437

#ifdef FEATURE_WLAN_CCX

3438

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3439

if( pConfig->isCcxIniFeatureEnabled )

3440

{

3441

pConfig->isFastTransitionEnabled = TRUE;

3442

}

Jeff Johnson

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

[diff] [blame]

3443

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3444

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

3445

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3446

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3447

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3448

#endif

3449

3450

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3451

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

3452

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

3453

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

3454

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

3455

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

3456

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

3457

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

3458

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3459

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3460

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3461

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3462

#endif

3463

3464

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3465

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3466

3467

//Enable/Disable MCC

3468

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3469

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3470

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

3471

//Scan Results Aging Time out value

3472

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3473

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

3474

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

3475

Jeff Johnson

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

[diff] [blame]

3476

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

3477

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3478

{

3479

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3488

3489

\brief hdd_execute_config_command() -

3490

3491

This function executes an arbitrary configuration set command

3492

3493

\param - pHddCtx - Pointer to the HDD Adapter.

3494

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

3495

3496

3497

\return - 0 for success, non zero for failure

3498

3499

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

3500

3501

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3502

{

3503

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

3504

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;

3513

unsigned int idx;

3514

unsigned int i;

3515

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3516

int rv;

Jeff Johnson

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

[diff] [blame]

3517

3518

// assume failure until proven otherwise

3519

vstatus = VOS_STATUS_E_FAILURE;

3520

3521

// clone the command so that we can manipulate it

3522

clone = kstrdup(command, GFP_ATOMIC);

3523

if (NULL == clone)

3524

{

3525

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3526

__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

3531

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

3532

pCmd = clone;

3533

3534

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

3540

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3545

name = pCmd;

3546

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]

3554

__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

3564

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3565

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3570

if ('\0' == *value_str)

3571

{

3572

// did not find a value

3573

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3574

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3579

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

3580

{

3581

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

{

// found a match

break;

}

}

if (tableSize == idx)

3588

{

3589

// did not match the name

3590

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3591

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3596

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

3597

{

3598

// does not support dynamic configuration

3599

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3600

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

3605

3606

switch (pRegEntry->RegType)

3607

{

3608

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3609

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

3610

if (rv < 0)

3611

goto done;

Jeff Johnson

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

[diff] [blame]

3612

if (value < pRegEntry->VarMin)

3613

{

3614

// out of range

3615

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3616

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3617

goto done;

3618

}

3619

if (value > pRegEntry->VarMax)

3620

{

3621

// out of range

3622

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3623

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3624

goto done;

3625

}

3626

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

3627

break;

3628

3629

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3630

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

3631

if (rv < 0)

3632

goto done;

Jeff Johnson

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

[diff] [blame]

3633

if (value < pRegEntry->VarMin)

3634

{

3635

// out of range

3636

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3637

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3638

goto done;

3639

}

3640

if (value > pRegEntry->VarMax)

3641

{

3642

// out of range

3643

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3644

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3645

goto done;

3646

}

3647

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

3648

break;

3649

3650

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3651

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

3652

if (rv < 0)

3653

goto done;

Jeff Johnson

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

[diff] [blame]

3654

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

3655

{

3656

// out of range

3657

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3658

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

Jeff Johnson

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

[diff] [blame]

3659

goto done;

3660

}

3661

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

3662

{

3663

// out of range

3664

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3665

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

Jeff Johnson

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

[diff] [blame]

3666

goto done;

3667

}

3668

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

3669

break;

3670

3671

case WLAN_PARAM_String:

3672

len_value_str = strlen(value_str);

3673

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

{

// too big

hddLog(LOGE,

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

3678

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3679

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3680

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

3681

goto done;

3682

}

3683

// copy string plus NUL

3684

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

3685

break;

3686

3687

case WLAN_PARAM_MacAddr:

3688

len_value_str = strlen(value_str);

3689

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3694

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3695

__func__, value_str,

Jeff Johnson