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

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

[diff] [blame]

2392

#ifdef WLAN_FEATURE_11AC

2393

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

2394

#endif

2395

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

2396

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

2397

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]

2398

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]

2399

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]

2400

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

2405

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2406

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

2407

{

2408

unsigned int idx;

2409

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2410

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

2411

v_U32_t value;

2412

char valueStr[CFG_VALUE_MAX_LEN];

2413

char configStr[CFG_ENTRY_MAX_LEN];

2414

char *fmt;

2415

void *pField;

2416

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2421

*pCur = '\0';

2422

2423

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

2424

{

2425

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

2426

2427

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

2428

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2429

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2430

{

2431

value = 0;

2432

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

2433

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

2446

}

2447

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2448

{

2449

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

2450

}

2451

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2452

{

2453

pMacAddr = (v_MACADDR_t *) pField;

2454

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2455

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

2466

}

2467

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2472

"*" : "");

2473

2474

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

2475

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

2476

#ifdef RETURN_IN_BUFFER

2477

if (curlen <= buflen)

2478

{

2479

// copy string + '\0'

2480

memcpy(pCur, configStr, curlen+1);

2481

2482

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2489

return VOS_STATUS_E_RESOURCES;

2490

}

2491

#else

2492

printk(KERN_CRIT "%s", configStr);

2493

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2498

// notify application that output is in system log

2499

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

2500

#endif // RETURN_IN_BUFFER

2501

2502

return VOS_STATUS_SUCCESS;

2503

}

2504

2505

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

2506

char *name, char** value)

2507

{

2508

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2509

unsigned long i;

2510

2511

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

2512

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

2513

*value = iniTable[i].value;

2514

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

2515

WLAN_INI_FILE, name, *value);

2516

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2524

{

2525

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

2526

return c-'0';

2527

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

2528

return c-'a'+10;

2529

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)

2537

{

2538

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2539

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2540

unsigned int idx;

2541

void *pField;

2542

char *value_str = NULL;

2543

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2548

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2549

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

2550

v_U32_t cbOutString;

2551

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2552

int rv;

Jeff Johnson

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

[diff] [blame]

2553

2554

// sanity test

2555

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2556

{

2557

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]

2558

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2559

}

2560

2561

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

2562

{

2563

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

2564

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

2565

2566

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

2567

2568

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

2569

{

2570

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

2571

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2572

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2573

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2578

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2579

{

2580

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

2581

// If not, use the default value.

2582

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2583

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

2584

if (rv < 0) {

2585

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

2586

__func__, pRegEntry->RegName);

2587

value = pRegEntry->VarDefault;

2588

}

Jeff Johnson

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

[diff] [blame]

2589

}

2590

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2591

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

2592

if (rv < 0) {

2593

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

2594

__func__, pRegEntry->RegName);

2595

value = pRegEntry->VarDefault;

2596

}

Jeff Johnson

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

[diff] [blame]

2597

}

2598

else {

2599

value = pRegEntry->VarDefault;

2600

}

2601

2602

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

2603

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2604

{

2605

if ( value > pRegEntry->VarMax )

2606

{

2607

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2608

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

Jeff Johnson

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

[diff] [blame]

2609

value = pRegEntry->VarMax;

2610

}

2611

2612

if ( value < pRegEntry->VarMin )

2613

{

2614

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2615

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

Jeff Johnson

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

[diff] [blame]

2616

value = pRegEntry->VarMin;

2617

}

2618

}

2619

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

2620

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2621

{

2622

if ( value > pRegEntry->VarMax )

2623

{

2624

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]

2625

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

Jeff Johnson

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

[diff] [blame]

2626

value = pRegEntry->VarDefault;

2627

}

2628

2629

if ( value < pRegEntry->VarMin )

2630

{

2631

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]

2632

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

Jeff Johnson

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

[diff] [blame]

2633

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2638

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

2639

}

2640

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2641

{

2642

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

2643

// If not, use the default value.

2644

if (VOS_STATUS_SUCCESS == match_status)

2645

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2646

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

2647

if (rv < 0) {

2648

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

2649

__func__, pRegEntry->RegName);

2650

svalue = (v_S31_t)pRegEntry->VarDefault;

2651

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2656

}

2657

2658

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

2659

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2660

{

2661

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

2662

{

2663

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2664

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

Jeff Johnson

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

[diff] [blame]

2665

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

2666

svalue = (v_S31_t)pRegEntry->VarMax;

2667

}

2668

2669

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

2670

{

2671

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2672

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

Jeff Johnson

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

[diff] [blame]

2673

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

2674

svalue = (v_S31_t)pRegEntry->VarMin;

2675

}

2676

}

2677

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

2678

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2679

{

2680

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

2681

{

2682

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

2683

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2684

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2685

(int)pRegEntry->VarMax,

2686

(int)pRegEntry->VarDefault );

2687

svalue = (v_S31_t)pRegEntry->VarDefault;

2688

}

2689

2690

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

2691

{

2692

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

2693

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2694

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2695

(int)pRegEntry->VarMin,

2696

(int)pRegEntry->VarDefault);

2697

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2702

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

2703

}

2704

// Handle string parameters

2705

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2706

{

2707

#ifdef WLAN_CFG_DEBUG

2708

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

2709

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

2710

#endif

2711

2712

if ( match_status == VOS_STATUS_SUCCESS)

2713

{

2714

len_value_str = strlen(value_str);

2715

2716

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

2717

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]

2718

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

Jeff Johnson

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

[diff] [blame]

2719

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

2720

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

2721

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

}

else

{

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

2726

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

}

}

else

{

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

2732

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

2733

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

2734

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

2735

}

2736

}

2737

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2738

{

2739

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2740

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2741

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

Jeff Johnson

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

[diff] [blame]

2742

continue;

2743

}

2744

candidate = (char*)pRegEntry->VarDefault;

2745

if ( match_status == VOS_STATUS_SUCCESS) {

2746

len_value_str = strlen(value_str);

2747

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

2748

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]

2749

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

Jeff Johnson

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

[diff] [blame]

2750

}

2751

else

2752

candidate = value_str;

2753

}

2754

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

2755

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

2756

{

2757

((char*)pField)[i] =

2758

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

2764

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2765

}

2766

2767

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

2768

if( (match_status == VOS_STATUS_SUCCESS) &&

2769

(idx < MAX_CFG_INI_ITEMS) )

2770

{

2771

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

}

}

print_hdd_cfg(pHddCtx);

2776

2777

return( ret_status );

2778

}

2779

2780

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2785

return eCSR_DOT11_MODE_abg;

2786

case (eHDD_DOT11_MODE_11b):

2787

return eCSR_DOT11_MODE_11b;

2788

case (eHDD_DOT11_MODE_11g):

2789

return eCSR_DOT11_MODE_11g;

2790

default:

2791

case (eHDD_DOT11_MODE_11n):

2792

return eCSR_DOT11_MODE_11n;

2793

case (eHDD_DOT11_MODE_11g_ONLY):

2794

return eCSR_DOT11_MODE_11g_ONLY;

2795

case (eHDD_DOT11_MODE_11n_ONLY):

2796

return eCSR_DOT11_MODE_11n_ONLY;

2797

case (eHDD_DOT11_MODE_11b_ONLY):

2798

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2799

#ifdef WLAN_FEATURE_11AC

2800

case (eHDD_DOT11_MODE_11ac_ONLY):

2801

return eCSR_DOT11_MODE_11ac_ONLY;

2802

case (eHDD_DOT11_MODE_11ac):

2803

return eCSR_DOT11_MODE_11ac;

2804

#endif

Jeff Johnson

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

[diff] [blame]

2805

case (eHDD_DOT11_MODE_AUTO):

2806

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2812

{

2813

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2814

tSmeBtcConfig btcParams;

2815

2816

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2817

2818

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2819

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2820

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2821

Jeff Johnson

32d95a3

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

[diff] [blame]

2822

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2823

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2824

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2825

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2826

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2827

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2828

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2829

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2830

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2831

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2832

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2833

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2834

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2835

Jeff Johnson

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

[diff] [blame]

2836

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2837

}

2838

2839

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

2840

{

2841

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2842

2843

tPmcBmpsConfigParams bmpsParams;

2844

2845

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

2846

2847

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

2848

{

2849

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

2850

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2851

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2852

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2853

}

2854

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

2855

{

2856

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

2857

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2858

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2859

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2860

}

2861

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

2862

{

2863

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

2864

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2865

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2866

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2867

}

2868

2869

if (pConfig->fIsImpsEnabled)

2870

{

2871

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2876

}

2877

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

2878

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

2879

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

2880

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

2881

Jeff Johnson

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

[diff] [blame]

2882

if (pConfig->fIsBmpsEnabled)

2883

{

2884

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2889

}

2890

2891

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2892

2893

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

2894

{

2895

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

2896

}

2897

2898

if(pConfig->fIsAutoBmpsTimerEnabled)

2899

{

2900

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2906

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 )

2911

{

2912

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2916

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

2917

{

2918

int val;

2919

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

2920

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

2921

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

2922

{

2923

intArray[*len] = (tANI_U8) val;

2924

*len += 1;

2925

}

2926

s = strpbrk( s, "," );

2927

if( s )

2928

s++;

2929

}

Jeff Johnson

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

[diff] [blame]

2930

2931

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2938

{

2939

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

2940

#ifdef WLAN_SOFTAP_VSTA_FEATURE

2941

tANI_U32 val;

2942

#endif

Jeff Johnson

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

[diff] [blame]

2943

2944

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2945

tSirMacHTCapabilityInfo htCapInfo;

2946

Jeff Johnson

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

[diff] [blame]

2947

2948

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2949

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

2950

{

2951

fStatus = FALSE;

2952

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

2953

}

2954

2955

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

2956

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2957

{

2958

fStatus = FALSE;

2959

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

2960

}

2961

2962

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

2963

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2964

{

2965

fStatus = FALSE;

2966

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

2967

}

2968

2969

if ( 0 != pConfig->Cfg1Id )

2970

{

2971

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

2972

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2973

{

2974

fStatus = FALSE;

2975

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

}

}

if ( 0 != pConfig->Cfg2Id )

2981

{

2982

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

2983

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2984

{

2985

fStatus = FALSE;

2986

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

}

}

if ( 0 != pConfig->Cfg3Id )

2991

{

2992

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

2993

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2994

{

2995

fStatus = FALSE;

2996

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

}

}

if ( 0 != pConfig->Cfg4Id )

3001

{

3002

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

3003

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3004

{

3005

fStatus = FALSE;

3006

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

}

}

if ( 0 != pConfig->Cfg5Id )

3011

{

3012

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

3013

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3014

{

3015

fStatus = FALSE;

3016

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

}

}

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

3021

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3022

{

3023

fStatus = FALSE;

3024

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

3025

}

3026

3027

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

3028

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3029

{

3030

fStatus = FALSE;

3031

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

3032

}

3033

3034

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

3035

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

3036

{

3037

fStatus = FALSE;

3038

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

3039

}

3040

3041

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

3042

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3043

{

3044

fStatus = FALSE;

3045

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

3046

}

3047

3048

if (pConfig->fIsAutoIbssBssid)

3049

{

3050

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

3051

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

3052

{

3053

fStatus = FALSE;

3054

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

}

}

else

{

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

3060

{

3061

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3062

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

3063

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

3064

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

3065

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

3066

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

3067

{

3068

fStatus = FALSE;

3069

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,

3080

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3081

{

3082

fStatus = FALSE;

3083

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

3084

}

3085

3086

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

3087

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3088

{

3089

fStatus = FALSE;

3090

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

3091

}

3092

3093

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

3094

{

3095

fStatus = FALSE;

3096

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

3097

}

3098

3099

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

3100

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3101

{

3102

fStatus = FALSE;

3103

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

3104

}

3105

3106

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

3107

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3108

{

3109

fStatus = FALSE;

3110

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

3111

}

3112

Jeff Johnson

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

[diff] [blame]

3113

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

3114

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3115

{

3116

fStatus = FALSE;

3117

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

3118

}

3119

3120

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

3121

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3122

{

3123

fStatus = FALSE;

3124

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

3125

}

3126

3127

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

3128

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3129

{

3130

fStatus = FALSE;

3131

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

3132

}

3133

Gopichand Nakkala

98a98af

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

[diff] [blame]

3134

#ifdef FEATURE_WLAN_LFR

3135

if (pConfig->isFastRoamIniFeatureEnabled)

3136

{

3137

pConfig->fEnableFwRssiMonitoring = TRUE;

3138

}

3139

#endif

3140

#ifdef FEATURE_WLAN_CCX

3141

if (pConfig->isCcxIniFeatureEnabled)

3142

{

3143

pConfig->fEnableFwRssiMonitoring = TRUE;

3144

}

3145

#endif

Jeff Johnson

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

[diff] [blame]

3146

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

3147

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3148

{

3149

fStatus = FALSE;

3150

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

3151

}

3152

3153

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

3154

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3155

{

3156

fStatus = FALSE;

3157

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

3158

}

3159

3160

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

3161

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3162

{

3163

fStatus = FALSE;

3164

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

3165

}

3166

3167

#ifdef WLAN_SOFTAP_FEATURE

3168

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

3169

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3170

{

3171

fStatus = FALSE;

3172

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

3173

}

3174

3175

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

3176

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3177

{

3178

fStatus = FALSE;

3179

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

3180

}

3181

Jeff Johnson

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

[diff] [blame]

3182

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

3183

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3184

{

3185

fStatus = FALSE;

3186

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

3187

}

3188

3189

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

3190

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3191

{

3192

fStatus = FALSE;

3193

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

3198

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

3199

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3200

{

3201

fStatus = FALSE;

3202

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

3203

}

3204

3205

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

3206

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3207

{

3208

fStatus = FALSE;

3209

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

3210

}

3211

3212

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

3213

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3214

{

3215

fStatus = FALSE;

3216

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

3217

}

3218

3219

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

3220

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3221

#endif

3222

3223

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

3224

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3225

{

3226

fStatus = FALSE;

3227

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

3228

}

3229

3230

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

3231

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3232

{

3233

fStatus = FALSE;

3234

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

3235

}

3236

3237

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

3238

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3239

{

3240

fStatus = FALSE;

3241

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

3242

}

3243

3244

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

3245

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3246

{

3247

fStatus = FALSE;

3248

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

3249

}

3250

3251

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

3252

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3253

{

3254

fStatus = FALSE;

3255

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

3256

}

3257

3258

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

3259

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3260

{

3261

fStatus = FALSE;

3262

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

3263

}

3264

3265

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

3266

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3267

{

3268

fStatus = FALSE;

3269

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

3270

}

3271

3272

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

3273

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3274

{

3275

fStatus = FALSE;

3276

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

3277

}

3278

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

3279

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3280

{

3281

fStatus = FALSE;

3282

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

3283

}

3284

3285

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

3286

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3287

{

3288

fStatus = FALSE;

3289

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

3290

}

3291

3292

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

3293

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3294

{

3295

fStatus = FALSE;

3296

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

3297

}

3298

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3299

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

3300

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3301

{

3302

fStatus = FALSE;

3303

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

3304

}

3305

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

3306

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3307

{

3308

fStatus = FALSE;

3309

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

3310

}

3311

3312

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

3313

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3314

{

3315

fStatus = FALSE;

3316

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

3317

}

3318

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

3319

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3320

{

3321

fStatus = FALSE;

3322

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,

3327

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3328

{

3329

fStatus = FALSE;

3330

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

3331

}

3332

3333

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3334

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3335

==eHAL_STATUS_FAILURE)

3336

{

3337

fStatus = FALSE;

3338

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

3339

}

3340

3341

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3342

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3343

==eHAL_STATUS_FAILURE)

3344

{

3345

fStatus = FALSE;

3346

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

3347

}

3348

3349

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3350

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

3351

{

3352

fStatus = FALSE;

3353

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

3354

}

3355

Jeff Johnson

d13512a

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

[diff] [blame]

3356

3357

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

3358

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3359

{

3360

fStatus = FALSE;

3361

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

3362

}

3363

Jeff Johnson

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

[diff] [blame]

3364

#ifdef WLAN_FEATURE_11AC

3365

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

3366

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

3367

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

3368

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

3369

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3370

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3376

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

3377

3378

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3379

temp, NULL, eANI_BOOLEAN_FALSE)

3380

==eHAL_STATUS_FAILURE)

3381

{

3382

fStatus = FALSE;

3383

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

3384

}

3385

3386

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

3387

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

3388

3389

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3390

temp, NULL, eANI_BOOLEAN_FALSE)

3391

==eHAL_STATUS_FAILURE)

3392

{

3393

fStatus = FALSE;

3394

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

3395

}

3396

3397

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

3398

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

3399

3400

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3401

temp, NULL, eANI_BOOLEAN_FALSE)

3402

==eHAL_STATUS_FAILURE)

3403

{

3404

fStatus = FALSE;

3405

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]

3411

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

3412

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3413

{

3414

fStatus = FALSE;

3415

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

3416

}

3417

Pratik Bhalgat

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

[diff] [blame]

3418

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3419

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3420

==eHAL_STATUS_FAILURE)

3421

{

3422

fStatus = FALSE;

3423

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

3424

}

3425

3426

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

3427

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3428

3429

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3430

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

3431

==eHAL_STATUS_FAILURE)

3432

{

3433

fStatus = FALSE;

3434

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

3435

}

3436

3437

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3438

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3439

==eHAL_STATUS_FAILURE)

3440

{

3441

fStatus = FALSE;

3442

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

3443

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3444

3445

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3446

if(pConfig->fEnableVSTASupport)

3447

{

3448

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

3449

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3450

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3455

}

3456

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

3457

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3458

{

3459

fStatus = FALSE;

3460

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

3461

}

3462

#endif

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3463

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3464

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3465

==eHAL_STATUS_FAILURE)

3466

{

3467

fStatus = FALSE;

3468

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

3469

}

Pratik Bhalgat

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

[diff] [blame]

3470

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3471

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

3472

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3473

{

3474

fStatus = FALSE;

3475

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

3476

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

3477

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

3478

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3479

{

3480

fStatus = FALSE;

3481

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

3482

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3488

3489

\brief hdd_init_set_sme_config() -

3490

3491

This function initializes the sme configuration parameters

3492

3493

\param - pHddCtx - Pointer to the HDD Adapter.

3494

3495

\return - 0 for success, non zero for failure

3496

3497

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

3498

3499

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3500

{

3501

VOS_STATUS status = VOS_STATUS_SUCCESS;

3502

eHalStatus halStatus;

3503

tSmeConfigParams smeConfig;

3504

3505

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3506

3507

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3508

3509

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3510

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

3511

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

3512

3513

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3514

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3515

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

Jeff Johnson

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

[diff] [blame]

3516

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3517

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3518

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3519

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3520

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3521

3522

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

3523

3524

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3525

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3526

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3527

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3528

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3529

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3530

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3531

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3532

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3533

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3534

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3535

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3536

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3537

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3538

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3539

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3540

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3541

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3542

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3543

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3544

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3545

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3546

#ifdef WLAN_AP_STA_CONCURRENCY

3547

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3548

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3549

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3550

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3551

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

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

[diff] [blame]

3552

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3553

#endif

Jeff Johnson

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

[diff] [blame]

3554

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3555

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3556

3557

#if defined WLAN_FEATURE_VOWIFI

3558

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3559

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3560

#endif

3561

//Remaining config params not obtained from registry

3562

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3563

#ifdef WLAN_FEATURE_11AC

3564

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

3565

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

3566

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Jeff Johnson

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

[diff] [blame]

3567

#endif

Jeff Johnson

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

[diff] [blame]

3568

smeConfig.csrConfig.AdHocChannel5G = 44;

3569

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3570

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3571

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3572

if (pConfig->nBandCapability == eCSR_BAND_24)

3573

{

3574

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3575

} else {

3576

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3577

}

Jeff Johnson

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

[diff] [blame]

3578

smeConfig.csrConfig.cbChoice = 0;

3579

smeConfig.csrConfig.bgScanInterval = 0;

3580

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3581

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3582

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3583

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3584

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3585

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

3586

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3587

#endif

Jeff Johnson

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

[diff] [blame]

3588

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3589

Jeff Johnson

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

[diff] [blame]

3590

//FIXME 11d config is hardcoded

3591

#ifdef WLAN_SOFTAP_FEATURE

3592

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3593

#endif

3594

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

3595

3596

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

3597

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

3598

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

3599

3600

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3605

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

3606

3607

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

3608

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

3609

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3610

}

3611

#endif

3612

hdd_set_power_save_config(pHddCtx, &smeConfig);

3613

hdd_set_btc_config(pHddCtx);

3614

3615

#ifdef WLAN_FEATURE_VOWIFI_11R

3616

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

3617

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3618

#ifdef FEATURE_WLAN_LFR

3619

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3620

if( pConfig->isFastRoamIniFeatureEnabled )

3621

{

3622

pConfig->isFastTransitionEnabled = TRUE;

3623

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

3624

#endif

Jeff Johnson

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

[diff] [blame]

3625

#ifdef FEATURE_WLAN_CCX

3626

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3627

if( pConfig->isCcxIniFeatureEnabled )

3628

{

3629

pConfig->isFastTransitionEnabled = TRUE;

3630

}

Jeff Johnson

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

[diff] [blame]

3631

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3632

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

3633

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3634

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3635

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3636

#endif

3637

3638

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3639

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

3640

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

3641

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

3642

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

3643

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

3644

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

3645

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

3646

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3647

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3648

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3649

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3650

#endif

3651

3652

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3653

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3654

3655

//Enable/Disable MCC

3656

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3657

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3658

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

3659

//Scan Results Aging Time out value

3660

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3661

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

3662

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

3663

Jeff Johnson

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

[diff] [blame]

3664

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

3665

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3666

{

3667

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3676

3677

\brief hdd_execute_config_command() -

3678

3679

This function executes an arbitrary configuration set command

3680

3681

\param - pHddCtx - Pointer to the HDD Adapter.

3682

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

3683

3684

3685

\return - 0 for success, non zero for failure

3686

3687

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

3688

3689

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3690

{

3691

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

3692

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;

3701

unsigned int idx;

3702

unsigned int i;

3703

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3704

int rv;

Jeff Johnson

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

[diff] [blame]

3705

3706

// assume failure until proven otherwise

3707

vstatus = VOS_STATUS_E_FAILURE;

3708

3709

// clone the command so that we can manipulate it

3710

clone = kstrdup(command, GFP_ATOMIC);

3711

if (NULL == clone)

3712

{

3713

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3714

__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

3719

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

3720

pCmd = clone;

3721

3722

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

3728

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3733

name = pCmd;

3734

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]

3742

__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

3752

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3753

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3758

if ('\0' == *value_str)

3759

{

3760

// did not find a value

3761

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3762

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3767

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

3768

{

3769

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

{

// found a match

break;

}

}

if (tableSize == idx)

3776

{

3777

// did not match the name

3778

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3779

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3784

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

3785

{

3786

// does not support dynamic configuration

3787

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3788

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

3793

3794

switch (pRegEntry->RegType)

3795

{

3796

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3797

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

3798

if (rv < 0)

3799

goto done;

Jeff Johnson

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

[diff] [blame]

3800

if (value < pRegEntry->VarMin)

3801

{

3802

// out of range

3803

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3804

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3805

goto done;

3806

}

3807

if (value > pRegEntry->VarMax)

3808

{

3809

// out of range

3810

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3811

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3812

goto done;

3813

}

3814

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

3815

break;

3816

3817

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3818

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

3819

if (rv < 0)

3820

goto done;

Jeff Johnson

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

[diff] [blame]

3821

if (value < pRegEntry->VarMin)

3822

{

3823

// out of range

3824

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3825

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3826

goto done;

3827

}

3828

if (value > pRegEntry->VarMax)

3829

{

3830

// out of range

3831

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3832

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3833

goto done;

3834

}

3835

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

3836

break;

3837

3838

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3839

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

3840

if (rv < 0)

3841

goto done;

Jeff Johnson

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

[diff] [blame]

3842

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

3843

{

3844

// out of range

3845

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3846

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

Jeff Johnson

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

[diff] [blame]

3847

goto done;

3848

}

3849

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

3850

{

3851

// out of range

3852

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3853

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

Jeff Johnson

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

[diff] [blame]

3854

goto done;

3855

}

3856

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

3857

break;

3858

3859

case WLAN_PARAM_String:

3860

len_value_str = strlen(value_str);

3861

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

{

// too big

hddLog(LOGE,

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

3866

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3867

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3868

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

3869

goto done;

3870

}

3871

// copy string plus NUL

3872

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

3873

break;

3874

3875

case WLAN_PARAM_MacAddr:

3876

len_value_str = strlen(value_str);

3877

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3882

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3883

__func__, value_str,

Jeff Johnson