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

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

[diff] [blame]

2363

#ifdef WLAN_FEATURE_11AC

2364

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

2365

#endif

2366

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

2367

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

2368

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]

2369

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]

2370

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

Madan Mohan Koyyalamudi

33df569

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

[diff] [blame]

2371

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

2376

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2377

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

2378

{

2379

unsigned int idx;

2380

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2381

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

2382

v_U32_t value;

2383

char valueStr[CFG_VALUE_MAX_LEN];

2384

char configStr[CFG_ENTRY_MAX_LEN];

2385

char *fmt;

2386

void *pField;

2387

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2392

*pCur = '\0';

2393

2394

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

2395

{

2396

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

2397

2398

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

2399

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2400

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2401

{

2402

value = 0;

2403

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

2404

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

2417

}

2418

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2419

{

2420

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

2421

}

2422

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2423

{

2424

pMacAddr = (v_MACADDR_t *) pField;

2425

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2426

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

2437

}

2438

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2443

"*" : "");

2444

2445

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

2446

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

2447

#ifdef RETURN_IN_BUFFER

2448

if (curlen <= buflen)

2449

{

2450

// copy string + '\0'

2451

memcpy(pCur, configStr, curlen+1);

2452

2453

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2460

return VOS_STATUS_E_RESOURCES;

2461

}

2462

#else

2463

printk(KERN_CRIT "%s", configStr);

2464

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2469

// notify application that output is in system log

2470

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

2471

#endif // RETURN_IN_BUFFER

2472

2473

return VOS_STATUS_SUCCESS;

2474

}

2475

2476

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

2477

char *name, char** value)

2478

{

2479

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2480

unsigned long i;

2481

2482

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

2483

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

2484

*value = iniTable[i].value;

2485

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

2486

WLAN_INI_FILE, name, *value);

2487

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2495

{

2496

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

2497

return c-'0';

2498

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

2499

return c-'a'+10;

2500

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)

2508

{

2509

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2510

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2511

unsigned int idx;

2512

void *pField;

2513

char *value_str = NULL;

2514

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2519

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2520

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

2521

v_U32_t cbOutString;

2522

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2523

int rv;

Jeff Johnson

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

[diff] [blame]

2524

2525

// sanity test

2526

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2527

{

2528

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]

2529

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2530

}

2531

2532

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

2533

{

2534

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

2535

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

2536

2537

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

2538

2539

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

2540

{

2541

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

2542

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2543

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2544

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2549

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2550

{

2551

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

2552

// If not, use the default value.

2553

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2554

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

2555

if (rv < 0) {

2556

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

2557

__func__, pRegEntry->RegName);

2558

value = pRegEntry->VarDefault;

2559

}

Jeff Johnson

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

[diff] [blame]

2560

}

2561

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2562

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

2563

if (rv < 0) {

2564

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

2565

__func__, pRegEntry->RegName);

2566

value = pRegEntry->VarDefault;

2567

}

Jeff Johnson

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

[diff] [blame]

2568

}

2569

else {

2570

value = pRegEntry->VarDefault;

2571

}

2572

2573

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

2574

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2575

{

2576

if ( value > pRegEntry->VarMax )

2577

{

2578

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2579

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

Jeff Johnson

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

[diff] [blame]

2580

value = pRegEntry->VarMax;

2581

}

2582

2583

if ( value < pRegEntry->VarMin )

2584

{

2585

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2586

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

Jeff Johnson

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

[diff] [blame]

2587

value = pRegEntry->VarMin;

2588

}

2589

}

2590

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

2591

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2592

{

2593

if ( value > pRegEntry->VarMax )

2594

{

2595

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]

2596

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

Jeff Johnson

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

[diff] [blame]

2597

value = pRegEntry->VarDefault;

2598

}

2599

2600

if ( value < pRegEntry->VarMin )

2601

{

2602

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]

2603

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

Jeff Johnson

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

[diff] [blame]

2604

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2609

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

2610

}

2611

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2612

{

2613

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

2614

// If not, use the default value.

2615

if (VOS_STATUS_SUCCESS == match_status)

2616

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2617

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

2618

if (rv < 0) {

2619

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

2620

__func__, pRegEntry->RegName);

2621

svalue = (v_S31_t)pRegEntry->VarDefault;

2622

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2627

}

2628

2629

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

2630

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2631

{

2632

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

2633

{

2634

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2635

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

Jeff Johnson

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

[diff] [blame]

2636

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

2637

svalue = (v_S31_t)pRegEntry->VarMax;

2638

}

2639

2640

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

2641

{

2642

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2643

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

Jeff Johnson

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

[diff] [blame]

2644

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

2645

svalue = (v_S31_t)pRegEntry->VarMin;

2646

}

2647

}

2648

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

2649

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2650

{

2651

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

2652

{

2653

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

2654

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2655

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2656

(int)pRegEntry->VarMax,

2657

(int)pRegEntry->VarDefault );

2658

svalue = (v_S31_t)pRegEntry->VarDefault;

2659

}

2660

2661

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

2662

{

2663

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

2664

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2665

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2666

(int)pRegEntry->VarMin,

2667

(int)pRegEntry->VarDefault);

2668

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2673

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

2674

}

2675

// Handle string parameters

2676

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2677

{

2678

#ifdef WLAN_CFG_DEBUG

2679

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

2680

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

2681

#endif

2682

2683

if ( match_status == VOS_STATUS_SUCCESS)

2684

{

2685

len_value_str = strlen(value_str);

2686

2687

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

2688

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]

2689

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

Jeff Johnson

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

[diff] [blame]

2690

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

2691

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

2692

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

}

else

{

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

2697

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

}

}

else

{

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

2703

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

2704

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

2705

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

2706

}

2707

}

2708

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2709

{

2710

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2711

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2712

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

Jeff Johnson

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

[diff] [blame]

2713

continue;

2714

}

2715

candidate = (char*)pRegEntry->VarDefault;

2716

if ( match_status == VOS_STATUS_SUCCESS) {

2717

len_value_str = strlen(value_str);

2718

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

2719

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]

2720

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

Jeff Johnson

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

[diff] [blame]

2721

}

2722

else

2723

candidate = value_str;

2724

}

2725

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

2726

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

2727

{

2728

((char*)pField)[i] =

2729

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

2735

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2736

}

2737

2738

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

2739

if( (match_status == VOS_STATUS_SUCCESS) &&

2740

(idx < MAX_CFG_INI_ITEMS) )

2741

{

2742

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

}

}

print_hdd_cfg(pHddCtx);

2747

2748

return( ret_status );

2749

}

2750

2751

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2756

return eCSR_DOT11_MODE_abg;

2757

case (eHDD_DOT11_MODE_11b):

2758

return eCSR_DOT11_MODE_11b;

2759

case (eHDD_DOT11_MODE_11g):

2760

return eCSR_DOT11_MODE_11g;

2761

default:

2762

case (eHDD_DOT11_MODE_11n):

2763

return eCSR_DOT11_MODE_11n;

2764

case (eHDD_DOT11_MODE_11g_ONLY):

2765

return eCSR_DOT11_MODE_11g_ONLY;

2766

case (eHDD_DOT11_MODE_11n_ONLY):

2767

return eCSR_DOT11_MODE_11n_ONLY;

2768

case (eHDD_DOT11_MODE_11b_ONLY):

2769

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2770

#ifdef WLAN_FEATURE_11AC

2771

case (eHDD_DOT11_MODE_11ac_ONLY):

2772

return eCSR_DOT11_MODE_11ac_ONLY;

2773

case (eHDD_DOT11_MODE_11ac):

2774

return eCSR_DOT11_MODE_11ac;

2775

#endif

Jeff Johnson

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

[diff] [blame]

2776

case (eHDD_DOT11_MODE_AUTO):

2777

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2783

{

2784

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2785

tSmeBtcConfig btcParams;

2786

2787

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2788

2789

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2790

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2791

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2792

Jeff Johnson

32d95a3

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

[diff] [blame]

2793

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2794

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2795

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2796

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2797

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2798

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2799

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2800

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2801

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2802

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2803

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2804

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2805

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2806

Jeff Johnson

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

[diff] [blame]

2807

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2808

}

2809

2810

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

2811

{

2812

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2813

2814

tPmcBmpsConfigParams bmpsParams;

2815

2816

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

2817

2818

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

2819

{

2820

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

2821

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2822

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2823

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2824

}

2825

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

2826

{

2827

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

2828

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2829

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2830

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2831

}

2832

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

2833

{

2834

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

2835

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2836

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2837

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2838

}

2839

2840

if (pConfig->fIsImpsEnabled)

2841

{

2842

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2847

}

2848

Madan Mohan Koyyalamudi

cbff3a7

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

[diff] [blame]

2849

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

2850

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

2851

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

2852

Jeff Johnson

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

[diff] [blame]

2853

if (pConfig->fIsBmpsEnabled)

2854

{

2855

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2860

}

2861

2862

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2863

2864

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

2865

{

2866

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

2867

}

2868

2869

if(pConfig->fIsAutoBmpsTimerEnabled)

2870

{

2871

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2877

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 )

2882

{

2883

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2887

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

2888

{

2889

int val;

2890

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

2891

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

2892

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

2893

{

2894

intArray[*len] = (tANI_U8) val;

2895

*len += 1;

2896

}

2897

s = strpbrk( s, "," );

2898

if( s )

2899

s++;

2900

}

Jeff Johnson

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

[diff] [blame]

2901

2902

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2909

{

2910

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

ba26127

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

[diff] [blame]

2911

#ifdef WLAN_SOFTAP_VSTA_FEATURE

2912

tANI_U32 val;

2913

#endif

Jeff Johnson

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

[diff] [blame]

2914

2915

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2916

tSirMacHTCapabilityInfo htCapInfo;

2917

Jeff Johnson

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

[diff] [blame]

2918

2919

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2920

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

2921

{

2922

fStatus = FALSE;

2923

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

2924

}

2925

2926

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

2927

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2928

{

2929

fStatus = FALSE;

2930

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

2931

}

2932

2933

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

2934

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2935

{

2936

fStatus = FALSE;

2937

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

2938

}

2939

2940

if ( 0 != pConfig->Cfg1Id )

2941

{

2942

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

2943

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2944

{

2945

fStatus = FALSE;

2946

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

}

}

if ( 0 != pConfig->Cfg2Id )

2952

{

2953

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

2954

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2955

{

2956

fStatus = FALSE;

2957

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

}

}

if ( 0 != pConfig->Cfg3Id )

2962

{

2963

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

2964

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2965

{

2966

fStatus = FALSE;

2967

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

}

}

if ( 0 != pConfig->Cfg4Id )

2972

{

2973

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

2974

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2975

{

2976

fStatus = FALSE;

2977

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

}

}

if ( 0 != pConfig->Cfg5Id )

2982

{

2983

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

2984

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2985

{

2986

fStatus = FALSE;

2987

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

}

}

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

2992

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2993

{

2994

fStatus = FALSE;

2995

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

2996

}

2997

2998

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

2999

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3000

{

3001

fStatus = FALSE;

3002

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

3003

}

3004

3005

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

3006

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

3007

{

3008

fStatus = FALSE;

3009

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

3010

}

3011

3012

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

3013

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3014

{

3015

fStatus = FALSE;

3016

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

3017

}

3018

3019

if (pConfig->fIsAutoIbssBssid)

3020

{

3021

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

3022

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

3023

{

3024

fStatus = FALSE;

3025

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

}

}

else

{

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

3031

{

3032

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3033

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

3034

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

3035

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

3036

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

3037

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

3038

{

3039

fStatus = FALSE;

3040

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,

3051

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3052

{

3053

fStatus = FALSE;

3054

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

3055

}

3056

3057

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

3058

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3059

{

3060

fStatus = FALSE;

3061

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

3062

}

3063

3064

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

3065

{

3066

fStatus = FALSE;

3067

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

3068

}

3069

3070

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

3071

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3072

{

3073

fStatus = FALSE;

3074

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

3075

}

3076

3077

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

3078

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3079

{

3080

fStatus = FALSE;

3081

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

3082

}

3083

Jeff Johnson

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

[diff] [blame]

3084

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

3085

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3086

{

3087

fStatus = FALSE;

3088

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

3089

}

3090

3091

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

3092

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3093

{

3094

fStatus = FALSE;

3095

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

3096

}

3097

3098

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

3099

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3100

{

3101

fStatus = FALSE;

3102

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

3103

}

3104

Gopichand Nakkala

7d6207d

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

[diff] [blame]

3105

#ifdef FEATURE_WLAN_LFR

3106

if (pConfig->isFastRoamIniFeatureEnabled)

3107

{

3108

pConfig->fEnableFwRssiMonitoring = TRUE;

3109

}

3110

#endif

3111

#ifdef FEATURE_WLAN_CCX

3112

if (pConfig->isCcxIniFeatureEnabled)

3113

{

3114

pConfig->fEnableFwRssiMonitoring = TRUE;

3115

}

3116

#endif

Jeff Johnson

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

[diff] [blame]

3117

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

3118

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3119

{

3120

fStatus = FALSE;

3121

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

3122

}

3123

3124

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

3125

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3126

{

3127

fStatus = FALSE;

3128

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

3129

}

3130

3131

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

3132

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3133

{

3134

fStatus = FALSE;

3135

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

3136

}

3137

3138

#ifdef WLAN_SOFTAP_FEATURE

3139

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

3140

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3141

{

3142

fStatus = FALSE;

3143

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

3144

}

3145

3146

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

3147

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3148

{

3149

fStatus = FALSE;

3150

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

3151

}

3152

Jeff Johnson

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

[diff] [blame]

3153

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

3154

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3155

{

3156

fStatus = FALSE;

3157

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

3158

}

3159

3160

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

3161

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3162

{

3163

fStatus = FALSE;

3164

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

3169

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

3170

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3171

{

3172

fStatus = FALSE;

3173

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

3174

}

3175

3176

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

3177

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3178

{

3179

fStatus = FALSE;

3180

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

3181

}

3182

3183

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

3184

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3185

{

3186

fStatus = FALSE;

3187

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

3188

}

3189

3190

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

3191

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3192

#endif

3193

3194

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

3195

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3196

{

3197

fStatus = FALSE;

3198

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

3199

}

3200

3201

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

3202

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3203

{

3204

fStatus = FALSE;

3205

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

3206

}

3207

3208

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

3209

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3210

{

3211

fStatus = FALSE;

3212

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

3213

}

3214

3215

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

3216

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3217

{

3218

fStatus = FALSE;

3219

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

3220

}

3221

3222

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

3223

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3224

{

3225

fStatus = FALSE;

3226

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

3227

}

3228

3229

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

3230

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3231

{

3232

fStatus = FALSE;

3233

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

3234

}

3235

3236

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

3237

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3238

{

3239

fStatus = FALSE;

3240

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

3241

}

3242

3243

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

3244

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3245

{

3246

fStatus = FALSE;

3247

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

3248

}

3249

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

3250

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3251

{

3252

fStatus = FALSE;

3253

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

3254

}

3255

3256

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

3257

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3258

{

3259

fStatus = FALSE;

3260

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

3261

}

3262

3263

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

3264

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3265

{

3266

fStatus = FALSE;

3267

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

3268

}

3269

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3270

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

3271

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3272

{

3273

fStatus = FALSE;

3274

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

3275

}

3276

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

3277

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3278

{

3279

fStatus = FALSE;

3280

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

3281

}

3282

3283

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

3284

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3285

{

3286

fStatus = FALSE;

3287

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

3288

}

3289

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

3290

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3291

{

3292

fStatus = FALSE;

3293

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,

3298

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3299

{

3300

fStatus = FALSE;

3301

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

3302

}

3303

3304

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3305

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3306

==eHAL_STATUS_FAILURE)

3307

{

3308

fStatus = FALSE;

3309

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

3310

}

3311

3312

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3313

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3314

==eHAL_STATUS_FAILURE)

3315

{

3316

fStatus = FALSE;

3317

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

3318

}

3319

3320

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3321

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

3322

{

3323

fStatus = FALSE;

3324

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

3325

}

3326

Jeff Johnson

d13512a

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

[diff] [blame]

3327

3328

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

3329

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3330

{

3331

fStatus = FALSE;

3332

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

3333

}

3334

Jeff Johnson

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

[diff] [blame]

3335

#ifdef WLAN_FEATURE_11AC

3336

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

3337

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

3338

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

3339

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

3340

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3341

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3347

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

3348

3349

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3350

temp, NULL, eANI_BOOLEAN_FALSE)

3351

==eHAL_STATUS_FAILURE)

3352

{

3353

fStatus = FALSE;

3354

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

3355

}

3356

3357

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

3358

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

3359

3360

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3361

temp, NULL, eANI_BOOLEAN_FALSE)

3362

==eHAL_STATUS_FAILURE)

3363

{

3364

fStatus = FALSE;

3365

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

3366

}

3367

3368

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

3369

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

3370

3371

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3372

temp, NULL, eANI_BOOLEAN_FALSE)

3373

==eHAL_STATUS_FAILURE)

3374

{

3375

fStatus = FALSE;

3376

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]

3382

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

3383

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3384

{

3385

fStatus = FALSE;

3386

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

3387

}

3388

Pratik Bhalgat

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

[diff] [blame]

3389

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3390

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3391

==eHAL_STATUS_FAILURE)

3392

{

3393

fStatus = FALSE;

3394

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

3395

}

3396

3397

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

3398

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3399

3400

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3401

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

3402

==eHAL_STATUS_FAILURE)

3403

{

3404

fStatus = FALSE;

3405

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

3406

}

3407

3408

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3409

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3410

==eHAL_STATUS_FAILURE)

3411

{

3412

fStatus = FALSE;

3413

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

3414

}

Gopichand Nakkala

ba26127

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

[diff] [blame]

3415

3416

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3417

if(pConfig->fEnableVSTASupport)

3418

{

3419

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

3420

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3421

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3426

}

3427

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

3428

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3429

{

3430

fStatus = FALSE;

3431

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

3432

}

3433

#endif

Madan Mohan Koyyalamudi

33df569

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

[diff] [blame]

3434

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3435

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3436

==eHAL_STATUS_FAILURE)

3437

{

3438

fStatus = FALSE;

3439

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

3440

}

Pratik Bhalgat

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

[diff] [blame]

3441

Madan Mohan Koyyalamudi

2826000

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

[diff] [blame]

3442

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

3443

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3444

{

3445

fStatus = FALSE;

3446

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

3447

}

Leela V Kiran Kumar Reddy Chirala

216ad4d

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

[diff] [blame^]

3448

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

3449

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3450

{

3451

fStatus = FALSE;

3452

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

3453

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3459

3460

\brief hdd_init_set_sme_config() -

3461

3462

This function initializes the sme configuration parameters

3463

3464

\param - pHddCtx - Pointer to the HDD Adapter.

3465

3466

\return - 0 for success, non zero for failure

3467

3468

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

3469

3470

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3471

{

3472

VOS_STATUS status = VOS_STATUS_SUCCESS;

3473

eHalStatus halStatus;

3474

tSmeConfigParams smeConfig;

3475

3476

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3477

3478

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3479

3480

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3481

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

3482

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

3483

3484

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3485

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3486

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

Jeff Johnson

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

[diff] [blame]

3487

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3488

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3489

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3490

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3491

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3492

3493

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

3494

3495

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3496

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3497

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3498

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3499

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3500

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3501

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3502

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3503

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3504

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3505

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3506

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3507

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3508

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3509

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3510

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3511

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3512

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3513

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3514

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3515

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3516

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3517

#ifdef WLAN_AP_STA_CONCURRENCY

3518

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3519

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3520

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3521

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3522

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Madan Mohan Koyyalamudi

8591f09

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

[diff] [blame]

3523

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3524

#endif

Jeff Johnson

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

[diff] [blame]

3525

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3526

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3527

3528

#if defined WLAN_FEATURE_VOWIFI

3529

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3530

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3531

#endif

3532

//Remaining config params not obtained from registry

3533

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3534

#ifdef WLAN_FEATURE_11AC

3535

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

31f9ebe

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

[diff] [blame]

3536

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Jeff Johnson

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

[diff] [blame]

3537

#endif

Jeff Johnson

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

[diff] [blame]

3538

smeConfig.csrConfig.AdHocChannel5G = 44;

3539

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3540

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3541

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

214557a

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

[diff] [blame]

3542

if (pConfig->nBandCapability == eCSR_BAND_24)

3543

{

3544

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3545

} else {

3546

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3547

}

Jeff Johnson

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

[diff] [blame]

3548

smeConfig.csrConfig.cbChoice = 0;

3549

smeConfig.csrConfig.bgScanInterval = 0;

3550

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3551

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3552

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3553

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3554

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

c4c0117

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

[diff] [blame]

3555

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

3556

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3557

#endif

Jeff Johnson

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

[diff] [blame]

3558

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3559

Jeff Johnson

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

[diff] [blame]

3560

//FIXME 11d config is hardcoded

3561

#ifdef WLAN_SOFTAP_FEATURE

3562

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3563

#endif

3564

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

3565

3566

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

3567

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

3568

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

3569

3570

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3575

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

3576

3577

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

3578

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

3579

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3580

}

3581

#endif

3582

hdd_set_power_save_config(pHddCtx, &smeConfig);

3583

hdd_set_btc_config(pHddCtx);

3584

3585

#ifdef WLAN_FEATURE_VOWIFI_11R

3586

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

3587

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3588

#ifdef FEATURE_WLAN_LFR

3589

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

7d6207d

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

[diff] [blame]

3590

if( pConfig->isFastRoamIniFeatureEnabled )

3591

{

3592

pConfig->isFastTransitionEnabled = TRUE;

3593

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

3594

#endif

Jeff Johnson

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

[diff] [blame]

3595

#ifdef FEATURE_WLAN_CCX

3596

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

7d6207d

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

[diff] [blame]

3597

if( pConfig->isCcxIniFeatureEnabled )

3598

{

3599

pConfig->isFastTransitionEnabled = TRUE;

3600

}

Jeff Johnson

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

[diff] [blame]

3601

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3602

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

3603

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3604

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

f4289db

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

[diff] [blame]

3605

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3606

#endif

3607

3608

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3609

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

3610

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

3611

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

3612

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

3613

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

3614

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

3615

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

3616

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3617

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3618

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3619

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3620

#endif

3621

3622

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3623

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3624

3625

//Enable/Disable MCC

3626

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3627

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3628

Madan Mohan Koyyalamudi

7da2fd7

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

[diff] [blame]

3629

//Scan Results Aging Time out value

3630

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3631

Gopichand Nakkala

b7ed0a6

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

[diff] [blame]

3632

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

3633

Jeff Johnson

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

[diff] [blame]

3634

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

3635

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3636

{

3637

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3646

3647

\brief hdd_execute_config_command() -

3648

3649

This function executes an arbitrary configuration set command

3650

3651

\param - pHddCtx - Pointer to the HDD Adapter.

3652

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

3653

3654

3655

\return - 0 for success, non zero for failure

3656

3657

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

3658

3659

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3660

{

3661

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

3662

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;

3671

unsigned int idx;

3672

unsigned int i;

3673

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3674

int rv;

Jeff Johnson

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

[diff] [blame]

3675

3676

// assume failure until proven otherwise

3677

vstatus = VOS_STATUS_E_FAILURE;

3678

3679

// clone the command so that we can manipulate it

3680

clone = kstrdup(command, GFP_ATOMIC);

3681

if (NULL == clone)

3682

{

3683

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3684

__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

3689

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

3690

pCmd = clone;

3691

3692

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

3698

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3703

name = pCmd;

3704

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]

3712

__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

3722

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3723

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3728

if ('\0' == *value_str)

3729

{

3730

// did not find a value

3731

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3732

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3737

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

3738

{

3739

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

{

// found a match

break;

}

}

if (tableSize == idx)

3746

{

3747

// did not match the name

3748

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3749

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3754

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

3755

{

3756

// does not support dynamic configuration

3757

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3758

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

3763

3764

switch (pRegEntry->RegType)

3765

{

3766

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3767

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

3768

if (rv < 0)

3769

goto done;

Jeff Johnson

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

[diff] [blame]

3770

if (value < pRegEntry->VarMin)

3771

{

3772

// out of range

3773

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3774

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3775

goto done;

3776

}

3777

if (value > pRegEntry->VarMax)

3778

{

3779

// out of range

3780

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3781

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3782

goto done;

3783

}

3784

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

3785

break;

3786

3787

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3788

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

3789

if (rv < 0)

3790

goto done;

Jeff Johnson

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

[diff] [blame]

3791

if (value < pRegEntry->VarMin)

3792

{

3793

// out of range

3794

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3795

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3796

goto done;

3797

}

3798

if (value > pRegEntry->VarMax)

3799

{

3800

// out of range

3801

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3802

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3803

goto done;

3804

}

3805

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

3806

break;

3807

3808

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3809

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

3810

if (rv < 0)

3811

goto done;

Jeff Johnson

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

[diff] [blame]

3812

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

3813

{

3814

// out of range

3815

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3816

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

Jeff Johnson

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

[diff] [blame]

3817

goto done;

3818

}

3819

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

3820

{

3821

// out of range

3822

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3823

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

Jeff Johnson

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

[diff] [blame]

3824

goto done;

3825

}

3826

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

3827

break;

3828

3829

case WLAN_PARAM_String:

3830

len_value_str = strlen(value_str);

3831

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

{

// too big

hddLog(LOGE,

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

3836

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3837

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3838

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

3839

goto done;

3840

}

3841

// copy string plus NUL

3842

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

3843

break;

3844

3845

case WLAN_PARAM_MacAddr:

3846

len_value_str = strlen(value_str);

3847

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3852

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3853

__func__, value_str,

Jeff Johnson