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

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

[diff] [blame]

2261

#ifdef WLAN_FEATURE_11AC

2262

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

2263

#endif

2264

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

2265

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

2266

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]

2267

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]

2268

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]

2269

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

2274

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2275

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

2276

{

2277

unsigned int idx;

2278

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2279

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

2280

v_U32_t value;

2281

char valueStr[CFG_VALUE_MAX_LEN];

2282

char configStr[CFG_ENTRY_MAX_LEN];

2283

char *fmt;

2284

void *pField;

2285

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2290

*pCur = '\0';

2291

2292

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

2293

{

2294

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

2295

2296

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

2297

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2298

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2299

{

2300

value = 0;

2301

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

2302

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

2315

}

2316

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2317

{

2318

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

2319

}

2320

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2321

{

2322

pMacAddr = (v_MACADDR_t *) pField;

2323

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2324

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

2335

}

2336

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2341

"*" : "");

2342

2343

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

2344

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

2345

#ifdef RETURN_IN_BUFFER

2346

if (curlen <= buflen)

2347

{

2348

// copy string + '\0'

2349

memcpy(pCur, configStr, curlen+1);

2350

2351

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2358

return VOS_STATUS_E_RESOURCES;

2359

}

2360

#else

2361

printk(KERN_CRIT "%s", configStr);

2362

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2367

// notify application that output is in system log

2368

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

2369

#endif // RETURN_IN_BUFFER

2370

2371

return VOS_STATUS_SUCCESS;

2372

}

2373

2374

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

2375

char *name, char** value)

2376

{

2377

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2378

unsigned long i;

2379

2380

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

2381

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

2382

*value = iniTable[i].value;

2383

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

2384

WLAN_INI_FILE, name, *value);

2385

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2393

{

2394

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

2395

return c-'0';

2396

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

2397

return c-'a'+10;

2398

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)

2406

{

2407

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2408

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2409

unsigned int idx;

2410

void *pField;

2411

char *value_str = NULL;

2412

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2417

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2418

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

2419

v_U32_t cbOutString;

2420

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2421

int rv;

Jeff Johnson

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

[diff] [blame]

2422

2423

// sanity test

2424

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2425

{

2426

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]

2427

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2428

}

2429

2430

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

2431

{

2432

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

2433

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

2434

2435

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

2436

2437

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

2438

{

2439

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

2440

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2441

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2442

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2447

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2448

{

2449

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

2450

// If not, use the default value.

2451

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2452

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

2453

if (rv < 0) {

2454

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

2455

__func__, pRegEntry->RegName);

2456

value = pRegEntry->VarDefault;

2457

}

Jeff Johnson

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

[diff] [blame]

2458

}

2459

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2460

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

2461

if (rv < 0) {

2462

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

2463

__func__, pRegEntry->RegName);

2464

value = pRegEntry->VarDefault;

2465

}

Jeff Johnson

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

[diff] [blame]

2466

}

2467

else {

2468

value = pRegEntry->VarDefault;

2469

}

2470

2471

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

2472

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2473

{

2474

if ( value > pRegEntry->VarMax )

2475

{

2476

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2477

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

Jeff Johnson

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

[diff] [blame]

2478

value = pRegEntry->VarMax;

2479

}

2480

2481

if ( value < pRegEntry->VarMin )

2482

{

2483

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2484

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

Jeff Johnson

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

[diff] [blame]

2485

value = pRegEntry->VarMin;

2486

}

2487

}

2488

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

2489

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2490

{

2491

if ( value > pRegEntry->VarMax )

2492

{

2493

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]

2494

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

Jeff Johnson

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

[diff] [blame]

2495

value = pRegEntry->VarDefault;

2496

}

2497

2498

if ( value < pRegEntry->VarMin )

2499

{

2500

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]

2501

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

Jeff Johnson

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

[diff] [blame]

2502

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2507

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

2508

}

2509

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2510

{

2511

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

2512

// If not, use the default value.

2513

if (VOS_STATUS_SUCCESS == match_status)

2514

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2515

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

2516

if (rv < 0) {

2517

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

2518

__func__, pRegEntry->RegName);

2519

svalue = (v_S31_t)pRegEntry->VarDefault;

2520

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2525

}

2526

2527

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

2528

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2529

{

2530

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

2531

{

2532

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2533

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

Jeff Johnson

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

[diff] [blame]

2534

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

2535

svalue = (v_S31_t)pRegEntry->VarMax;

2536

}

2537

2538

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

2539

{

2540

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2541

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

Jeff Johnson

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

[diff] [blame]

2542

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

2543

svalue = (v_S31_t)pRegEntry->VarMin;

2544

}

2545

}

2546

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

2547

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2548

{

2549

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

2550

{

2551

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

2552

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2553

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2554

(int)pRegEntry->VarMax,

2555

(int)pRegEntry->VarDefault );

2556

svalue = (v_S31_t)pRegEntry->VarDefault;

2557

}

2558

2559

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

2560

{

2561

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

2562

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2563

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2564

(int)pRegEntry->VarMin,

2565

(int)pRegEntry->VarDefault);

2566

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2571

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

2572

}

2573

// Handle string parameters

2574

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2575

{

2576

#ifdef WLAN_CFG_DEBUG

2577

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

2578

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

2579

#endif

2580

2581

if ( match_status == VOS_STATUS_SUCCESS)

2582

{

2583

len_value_str = strlen(value_str);

2584

2585

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

2586

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]

2587

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

Jeff Johnson

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

[diff] [blame]

2588

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

2589

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

2590

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

}

else

{

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

2595

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

}

}

else

{

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

2601

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

2602

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

2603

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

2604

}

2605

}

2606

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2607

{

2608

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2609

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2610

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

Jeff Johnson

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

[diff] [blame]

2611

continue;

2612

}

2613

candidate = (char*)pRegEntry->VarDefault;

2614

if ( match_status == VOS_STATUS_SUCCESS) {

2615

len_value_str = strlen(value_str);

2616

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

2617

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]

2618

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

Jeff Johnson

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

[diff] [blame]

2619

}

2620

else

2621

candidate = value_str;

2622

}

2623

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

2624

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

2625

{

2626

((char*)pField)[i] =

2627

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

2633

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2634

}

2635

2636

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

2637

if( (match_status == VOS_STATUS_SUCCESS) &&

2638

(idx < MAX_CFG_INI_ITEMS) )

2639

{

2640

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

}

}

print_hdd_cfg(pHddCtx);

2645

2646

return( ret_status );

2647

}

2648

2649

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2654

return eCSR_DOT11_MODE_abg;

2655

case (eHDD_DOT11_MODE_11b):

2656

return eCSR_DOT11_MODE_11b;

2657

case (eHDD_DOT11_MODE_11g):

2658

return eCSR_DOT11_MODE_11g;

2659

default:

2660

case (eHDD_DOT11_MODE_11n):

2661

return eCSR_DOT11_MODE_11n;

2662

case (eHDD_DOT11_MODE_11g_ONLY):

2663

return eCSR_DOT11_MODE_11g_ONLY;

2664

case (eHDD_DOT11_MODE_11n_ONLY):

2665

return eCSR_DOT11_MODE_11n_ONLY;

2666

case (eHDD_DOT11_MODE_11b_ONLY):

2667

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2668

#ifdef WLAN_FEATURE_11AC

2669

case (eHDD_DOT11_MODE_11ac_ONLY):

2670

return eCSR_DOT11_MODE_11ac_ONLY;

2671

case (eHDD_DOT11_MODE_11ac):

2672

return eCSR_DOT11_MODE_11ac;

2673

#endif

Jeff Johnson

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

[diff] [blame]

2674

case (eHDD_DOT11_MODE_AUTO):

2675

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2681

{

2682

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2683

tSmeBtcConfig btcParams;

2684

2685

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2686

2687

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2688

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2689

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2690

Jeff Johnson

32d95a3

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

[diff] [blame]

2691

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2692

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2693

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2694

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2695

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2696

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2697

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2698

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2699

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2700

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2701

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2702

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2703

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2704

Jeff Johnson

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

[diff] [blame]

2705

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2706

}

2707

2708

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

2709

{

2710

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2711

2712

tPmcBmpsConfigParams bmpsParams;

2713

2714

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

2715

2716

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

2717

{

2718

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

2719

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2720

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2721

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2722

}

2723

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

2724

{

2725

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

2726

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2727

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2728

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2729

}

2730

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

2731

{

2732

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

2733

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2734

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2735

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2736

}

2737

2738

if (pConfig->fIsImpsEnabled)

2739

{

2740

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2745

}

2746

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

2747

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

2748

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

2749

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

2750

Jeff Johnson

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

[diff] [blame]

2751

if (pConfig->fIsBmpsEnabled)

2752

{

2753

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2758

}

2759

2760

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2761

2762

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

2763

{

2764

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

2765

}

2766

2767

if(pConfig->fIsAutoBmpsTimerEnabled)

2768

{

2769

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2775

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 )

2780

{

2781

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2785

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

2786

{

2787

int val;

2788

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

2789

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

2790

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

2791

{

2792

intArray[*len] = (tANI_U8) val;

2793

*len += 1;

2794

}

2795

s = strpbrk( s, "," );

2796

if( s )

2797

s++;

2798

}

Jeff Johnson

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

[diff] [blame]

2799

2800

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2807

{

2808

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

2809

#ifdef WLAN_SOFTAP_VSTA_FEATURE

2810

tANI_U32 val;

2811

#endif

Jeff Johnson

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

[diff] [blame]

2812

2813

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2814

tSirMacHTCapabilityInfo htCapInfo;

2815

Jeff Johnson

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

[diff] [blame]

2816

2817

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2818

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

2819

{

2820

fStatus = FALSE;

2821

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

2822

}

2823

2824

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

2825

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2826

{

2827

fStatus = FALSE;

2828

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

2829

}

2830

2831

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

2832

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2833

{

2834

fStatus = FALSE;

2835

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

2836

}

2837

2838

if ( 0 != pConfig->Cfg1Id )

2839

{

2840

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

2841

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2842

{

2843

fStatus = FALSE;

2844

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

}

}

if ( 0 != pConfig->Cfg2Id )

2850

{

2851

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

2852

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2853

{

2854

fStatus = FALSE;

2855

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

}

}

if ( 0 != pConfig->Cfg3Id )

2860

{

2861

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

2862

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2863

{

2864

fStatus = FALSE;

2865

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

}

}

if ( 0 != pConfig->Cfg4Id )

2870

{

2871

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

2872

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2873

{

2874

fStatus = FALSE;

2875

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

}

}

if ( 0 != pConfig->Cfg5Id )

2880

{

2881

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

2882

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2883

{

2884

fStatus = FALSE;

2885

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

}

}

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

2890

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2891

{

2892

fStatus = FALSE;

2893

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

2894

}

2895

2896

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

2897

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2898

{

2899

fStatus = FALSE;

2900

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

2901

}

2902

2903

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2904

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

2905

{

2906

fStatus = FALSE;

2907

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

2908

}

2909

2910

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

2911

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2912

{

2913

fStatus = FALSE;

2914

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

2915

}

2916

2917

if (pConfig->fIsAutoIbssBssid)

2918

{

2919

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

2920

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

2921

{

2922

fStatus = FALSE;

2923

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

}

}

else

{

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

2929

{

2930

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2931

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

2932

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

2933

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

2934

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

2935

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

2936

{

2937

fStatus = FALSE;

2938

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,

2949

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2950

{

2951

fStatus = FALSE;

2952

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

2953

}

2954

2955

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

2956

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2957

{

2958

fStatus = FALSE;

2959

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

2960

}

2961

2962

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

2963

{

2964

fStatus = FALSE;

2965

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

2966

}

2967

2968

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

2969

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2970

{

2971

fStatus = FALSE;

2972

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

2973

}

2974

2975

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

2976

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2977

{

2978

fStatus = FALSE;

2979

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

2980

}

2981

Jeff Johnson

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

[diff] [blame]

2982

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

2983

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2984

{

2985

fStatus = FALSE;

2986

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

2987

}

2988

2989

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

2990

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2991

{

2992

fStatus = FALSE;

2993

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

2994

}

2995

2996

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

2997

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2998

{

2999

fStatus = FALSE;

3000

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

3001

}

3002

Gopichand Nakkala

98a98af

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

[diff] [blame]

3003

#ifdef FEATURE_WLAN_LFR

3004

if (pConfig->isFastRoamIniFeatureEnabled)

3005

{

3006

pConfig->fEnableFwRssiMonitoring = TRUE;

3007

}

3008

#endif

3009

#ifdef FEATURE_WLAN_CCX

3010

if (pConfig->isCcxIniFeatureEnabled)

3011

{

3012

pConfig->fEnableFwRssiMonitoring = TRUE;

3013

}

3014

#endif

Jeff Johnson

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

[diff] [blame]

3015

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

3016

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3017

{

3018

fStatus = FALSE;

3019

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

3020

}

3021

3022

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

3023

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3024

{

3025

fStatus = FALSE;

3026

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

3027

}

3028

3029

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

3030

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3031

{

3032

fStatus = FALSE;

3033

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

3034

}

3035

3036

#ifdef WLAN_SOFTAP_FEATURE

3037

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

3038

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3039

{

3040

fStatus = FALSE;

3041

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

3042

}

3043

3044

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

3045

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3046

{

3047

fStatus = FALSE;

3048

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

3049

}

3050

Jeff Johnson

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

[diff] [blame]

3051

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

3052

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3053

{

3054

fStatus = FALSE;

3055

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

3056

}

3057

3058

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

3059

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3060

{

3061

fStatus = FALSE;

3062

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

3067

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

3068

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3069

{

3070

fStatus = FALSE;

3071

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

3072

}

3073

3074

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

3075

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3076

{

3077

fStatus = FALSE;

3078

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

3079

}

3080

3081

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

3082

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3083

{

3084

fStatus = FALSE;

3085

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

3086

}

3087

3088

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

3089

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3090

#endif

3091

3092

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

3093

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3094

{

3095

fStatus = FALSE;

3096

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

3097

}

3098

3099

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

3100

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3101

{

3102

fStatus = FALSE;

3103

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

3104

}

3105

3106

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

3107

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3108

{

3109

fStatus = FALSE;

3110

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

3111

}

3112

3113

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

3114

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3115

{

3116

fStatus = FALSE;

3117

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

3118

}

3119

3120

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

3121

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3122

{

3123

fStatus = FALSE;

3124

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

3125

}

3126

3127

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

3128

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3129

{

3130

fStatus = FALSE;

3131

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

3132

}

3133

3134

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

3135

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3136

{

3137

fStatus = FALSE;

3138

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

3139

}

3140

3141

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

3142

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3143

{

3144

fStatus = FALSE;

3145

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

3146

}

3147

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

3148

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3149

{

3150

fStatus = FALSE;

3151

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

3152

}

3153

3154

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

3155

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3156

{

3157

fStatus = FALSE;

3158

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

3159

}

3160

3161

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

3162

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3163

{

3164

fStatus = FALSE;

3165

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

3166

}

3167

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3168

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

3169

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3170

{

3171

fStatus = FALSE;

3172

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

3173

}

3174

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

3175

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3176

{

3177

fStatus = FALSE;

3178

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

3179

}

3180

3181

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

3182

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3183

{

3184

fStatus = FALSE;

3185

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

3186

}

3187

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

3188

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3189

{

3190

fStatus = FALSE;

3191

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,

3196

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3197

{

3198

fStatus = FALSE;

3199

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

3200

}

3201

3202

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3203

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3204

==eHAL_STATUS_FAILURE)

3205

{

3206

fStatus = FALSE;

3207

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

3208

}

3209

3210

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3211

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3212

==eHAL_STATUS_FAILURE)

3213

{

3214

fStatus = FALSE;

3215

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

3216

}

3217

3218

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3219

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

3220

{

3221

fStatus = FALSE;

3222

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

3223

}

3224

Jeff Johnson

d13512a

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

[diff] [blame]

3225

3226

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

3227

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3228

{

3229

fStatus = FALSE;

3230

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

3231

}

3232

Jeff Johnson

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

[diff] [blame]

3233

#ifdef WLAN_FEATURE_11AC

3234

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

3235

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

3236

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

3237

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

3238

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3239

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3245

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

3246

3247

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3248

temp, NULL, eANI_BOOLEAN_FALSE)

3249

==eHAL_STATUS_FAILURE)

3250

{

3251

fStatus = FALSE;

3252

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

3253

}

3254

3255

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

3256

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

3257

3258

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3259

temp, NULL, eANI_BOOLEAN_FALSE)

3260

==eHAL_STATUS_FAILURE)

3261

{

3262

fStatus = FALSE;

3263

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

3264

}

3265

3266

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

3267

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

3268

3269

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3270

temp, NULL, eANI_BOOLEAN_FALSE)

3271

==eHAL_STATUS_FAILURE)

3272

{

3273

fStatus = FALSE;

3274

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]

3280

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

3281

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3282

{

3283

fStatus = FALSE;

3284

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

3285

}

3286

Pratik Bhalgat

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

[diff] [blame]

3287

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3288

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3289

==eHAL_STATUS_FAILURE)

3290

{

3291

fStatus = FALSE;

3292

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

3293

}

3294

3295

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

3296

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3297

3298

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3299

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

3300

==eHAL_STATUS_FAILURE)

3301

{

3302

fStatus = FALSE;

3303

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

3304

}

3305

3306

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3307

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3308

==eHAL_STATUS_FAILURE)

3309

{

3310

fStatus = FALSE;

3311

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

3312

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3313

3314

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3315

if(pConfig->fEnableVSTASupport)

3316

{

3317

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

3318

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3319

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3324

}

3325

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

3326

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3327

{

3328

fStatus = FALSE;

3329

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

3330

}

3331

#endif

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3332

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3333

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3334

==eHAL_STATUS_FAILURE)

3335

{

3336

fStatus = FALSE;

3337

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

3338

}

Pratik Bhalgat

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

[diff] [blame]

3339

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3340

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

3341

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3342

{

3343

fStatus = FALSE;

3344

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

3345

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3351

3352

\brief hdd_init_set_sme_config() -

3353

3354

This function initializes the sme configuration parameters

3355

3356

\param - pHddCtx - Pointer to the HDD Adapter.

3357

3358

\return - 0 for success, non zero for failure

3359

3360

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

3361

3362

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3363

{

3364

VOS_STATUS status = VOS_STATUS_SUCCESS;

3365

eHalStatus halStatus;

3366

tSmeConfigParams smeConfig;

3367

3368

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3369

3370

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3371

3372

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3373

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

3374

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

3375

3376

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3377

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3378

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

Jeff Johnson

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

[diff] [blame]

3379

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3380

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3381

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3382

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3383

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3384

3385

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

3386

3387

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3388

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3389

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3390

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3391

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3392

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3393

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3394

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3395

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3396

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3397

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3398

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3399

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3400

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3401

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3402

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3403

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3404

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3405

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3406

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3407

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3408

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3409

#ifdef WLAN_AP_STA_CONCURRENCY

3410

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3411

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3412

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3413

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3414

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

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

[diff] [blame]

3415

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3416

#endif

Jeff Johnson

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

[diff] [blame]

3417

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3418

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3419

3420

#if defined WLAN_FEATURE_VOWIFI

3421

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3422

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3423

#endif

3424

//Remaining config params not obtained from registry

3425

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3426

#ifdef WLAN_FEATURE_11AC

3427

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3428

#endif

Jeff Johnson

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

[diff] [blame]

3429

smeConfig.csrConfig.AdHocChannel5G = 44;

3430

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3431

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3432

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3433

if (pConfig->nBandCapability == eCSR_BAND_24)

3434

{

3435

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3436

} else {

3437

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3438

}

Jeff Johnson

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

[diff] [blame]

3439

smeConfig.csrConfig.cbChoice = 0;

3440

smeConfig.csrConfig.bgScanInterval = 0;

3441

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3442

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3443

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3444

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3445

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3446

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

3447

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3448

#endif

Jeff Johnson

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

[diff] [blame]

3449

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3450

Jeff Johnson

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

[diff] [blame]

3451

//FIXME 11d config is hardcoded

3452

#ifdef WLAN_SOFTAP_FEATURE

3453

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3454

#endif

3455

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

3456

3457

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

3458

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

3459

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

3460

3461

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3466

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

3467

3468

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

3469

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

3470

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3471

}

3472

#endif

3473

hdd_set_power_save_config(pHddCtx, &smeConfig);

3474

hdd_set_btc_config(pHddCtx);

3475

3476

#ifdef WLAN_FEATURE_VOWIFI_11R

3477

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

3478

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3479

#ifdef FEATURE_WLAN_LFR

3480

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3481

if( pConfig->isFastRoamIniFeatureEnabled )

3482

{

3483

pConfig->isFastTransitionEnabled = TRUE;

3484

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

3485

#endif

Jeff Johnson

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

[diff] [blame]

3486

#ifdef FEATURE_WLAN_CCX

3487

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3488

if( pConfig->isCcxIniFeatureEnabled )

3489

{

3490

pConfig->isFastTransitionEnabled = TRUE;

3491

}

Jeff Johnson

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

[diff] [blame]

3492

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3493

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

3494

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3495

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3496

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3497

#endif

3498

3499

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3500

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

3501

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

3502

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

3503

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

3504

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

3505

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

3506

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

3507

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3508

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3509

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3510

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3511

#endif

3512

3513

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3514

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3515

3516

//Enable/Disable MCC

3517

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3518

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3519

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

3520

//Scan Results Aging Time out value

3521

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3522

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

3523

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

3524

Jeff Johnson

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

[diff] [blame]

3525

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

3526

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3527

{

3528

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3537

3538

\brief hdd_execute_config_command() -

3539

3540

This function executes an arbitrary configuration set command

3541

3542

\param - pHddCtx - Pointer to the HDD Adapter.

3543

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

3544

3545

3546

\return - 0 for success, non zero for failure

3547

3548

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

3549

3550

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3551

{

3552

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

3553

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;

3562

unsigned int idx;

3563

unsigned int i;

3564

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3565

int rv;

Jeff Johnson

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

[diff] [blame]

3566

3567

// assume failure until proven otherwise

3568

vstatus = VOS_STATUS_E_FAILURE;

3569

3570

// clone the command so that we can manipulate it

3571

clone = kstrdup(command, GFP_ATOMIC);

3572

if (NULL == clone)

3573

{

3574

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3575

__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

3580

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

3581

pCmd = clone;

3582

3583

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

3589

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3594

name = pCmd;

3595

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]

3603

__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

3613

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3614

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3619

if ('\0' == *value_str)

3620

{

3621

// did not find a value

3622

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3623

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3628

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

3629

{

3630

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

{

// found a match

break;

}

}

if (tableSize == idx)

3637

{

3638

// did not match the name

3639

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3640

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3645

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

3646

{

3647

// does not support dynamic configuration

3648

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3649

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

3654

3655

switch (pRegEntry->RegType)

3656

{

3657

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3658

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

3659

if (rv < 0)

3660

goto done;

Jeff Johnson

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

[diff] [blame]

3661

if (value < pRegEntry->VarMin)

3662

{

3663

// out of range

3664

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3665

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3666

goto done;

3667

}

3668

if (value > pRegEntry->VarMax)

3669

{

3670

// out of range

3671

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3672

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3673

goto done;

3674

}

3675

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

3676

break;

3677

3678

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3679

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

3680

if (rv < 0)

3681

goto done;

Jeff Johnson

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

[diff] [blame]

3682

if (value < pRegEntry->VarMin)

3683

{

3684

// out of range

3685

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3686

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3687

goto done;

3688

}

3689

if (value > pRegEntry->VarMax)

3690

{

3691

// out of range

3692

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3693

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3694

goto done;

3695

}

3696

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

3697

break;

3698

3699

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3700

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

3701

if (rv < 0)

3702

goto done;

Jeff Johnson

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

[diff] [blame]

3703

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

3704

{

3705

// out of range

3706

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3707

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

Jeff Johnson

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

[diff] [blame]

3708

goto done;

3709

}

3710

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

3711

{

3712

// out of range

3713

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3714

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

Jeff Johnson

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

[diff] [blame]

3715

goto done;

3716

}

3717

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

3718

break;

3719

3720

case WLAN_PARAM_String:

3721

len_value_str = strlen(value_str);

3722

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

{

// too big

hddLog(LOGE,

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

3727

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3728

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3729

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

3730

goto done;

3731

}

3732

// copy string plus NUL

3733

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

3734

break;

3735

3736

case WLAN_PARAM_MacAddr:

3737

len_value_str = strlen(value_str);

3738

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3743

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3744

__func__, value_str,

Jeff Johnson