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

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

[diff] [blame]

2612

#endif

2613

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [burstSizeDefinition] Value = [0x%x] ",pHddCtx->cfg_ini->burstSizeDefinition);

2614

VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH, "Name = [tsInfoAckPolicy] Value = [0x%x] ",pHddCtx->cfg_ini->tsInfoAckPolicy);

2615

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

2616

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

2617

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

2618

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

2619

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

2620

2621

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

2622

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

2623

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

2624

#ifdef WLAN_BTAMP_FEATURE

2625

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

2626

#endif //WLAN_BTAMP_FEATURE

2627

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

2628

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

2629

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

2630

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

2631

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

2632

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

2633

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

2634

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

2635

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

2636

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

2637

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

2638

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

2639

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

Jeff Johnson

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

[diff] [blame]

2640

#ifdef WLAN_FEATURE_11AC

2641

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

2642

#endif

2643

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

2644

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

2645

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

Pratik Bhalgat

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

[diff] [blame]

2646

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]

2647

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

Gopichand Nakkala

e620d5a

2013-04-26 05:45:57 -0700

[diff] [blame]

2648

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

2649

Jeff Johnson

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

[diff] [blame]

}

Gopichand Nakkala

2013-04-26 05:45:57 -0700

[diff] [blame]

2653

Jeff Johnson

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

[diff] [blame]

2654

#define CFG_VALUE_MAX_LEN 256

2655

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2656

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

2657

{

2658

unsigned int idx;

2659

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2660

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

2661

v_U32_t value;

2662

char valueStr[CFG_VALUE_MAX_LEN];

2663

char configStr[CFG_ENTRY_MAX_LEN];

2664

char *fmt;

2665

void *pField;

2666

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2671

*pCur = '\0';

2672

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2673

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

Jeff Johnson

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

[diff] [blame]

2674

{

2675

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

2676

2677

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

2678

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2679

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

Jeff Johnson

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

[diff] [blame]

2680

{

2681

value = 0;

2682

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

2683

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

2696

}

2697

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2698

{

2699

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

2700

}

2701

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2702

{

2703

pMacAddr = (v_MACADDR_t *) pField;

2704

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2705

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

2716

}

2717

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2722

"*" : "");

2723

2724

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

2725

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

2726

#ifdef RETURN_IN_BUFFER

2727

if (curlen <= buflen)

2728

{

2729

// copy string + '\0'

2730

memcpy(pCur, configStr, curlen+1);

2731

2732

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2739

return VOS_STATUS_E_RESOURCES;

2740

}

2741

#else

2742

printk(KERN_CRIT "%s", configStr);

2743

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2748

// notify application that output is in system log

2749

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

2750

#endif // RETURN_IN_BUFFER

2751

2752

return VOS_STATUS_SUCCESS;

2753

}

2754

2755

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2756

char *name, char** value)

Jeff Johnson

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

[diff] [blame]

2757

{

2758

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2759

unsigned long i;

2760

2761

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

2762

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

2763

*value = iniTable[i].value;

2764

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

2765

WLAN_INI_FILE, name, *value);

2766

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2774

{

2775

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

2776

return c-'0';

2777

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

2778

return c-'a'+10;

2779

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)

2787

{

2788

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2789

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2790

unsigned int idx;

2791

void *pField;

2792

char *value_str = NULL;

2793

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2798

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2799

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

2800

v_U32_t cbOutString;

2801

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2802

int rv;

Jeff Johnson

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

[diff] [blame]

2803

2804

// sanity test

2805

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2806

{

2807

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]

2808

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2809

}

2810

2811

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

2812

{

2813

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

2814

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

2815

2816

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

2817

2818

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

2819

{

2820

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

2821

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2822

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2823

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2828

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2829

{

2830

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

2831

// If not, use the default value.

2832

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2833

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

2834

if (rv < 0) {

2835

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

2836

__func__, pRegEntry->RegName);

2837

value = pRegEntry->VarDefault;

2838

}

Jeff Johnson

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

[diff] [blame]

2839

}

2840

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2841

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

2842

if (rv < 0) {

2843

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

2844

__func__, pRegEntry->RegName);

2845

value = pRegEntry->VarDefault;

2846

}

Jeff Johnson

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

[diff] [blame]

2847

}

2848

else {

2849

value = pRegEntry->VarDefault;

2850

}

2851

2852

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

2853

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2854

{

2855

if ( value > pRegEntry->VarMax )

2856

{

2857

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2858

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

Jeff Johnson

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

[diff] [blame]

2859

value = pRegEntry->VarMax;

2860

}

2861

2862

if ( value < pRegEntry->VarMin )

2863

{

2864

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2865

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

Jeff Johnson

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

[diff] [blame]

2866

value = pRegEntry->VarMin;

2867

}

2868

}

2869

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

2870

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2871

{

2872

if ( value > pRegEntry->VarMax )

2873

{

2874

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]

2875

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

Jeff Johnson

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

[diff] [blame]

2876

value = pRegEntry->VarDefault;

2877

}

2878

2879

if ( value < pRegEntry->VarMin )

2880

{

2881

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]

2882

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

Jeff Johnson

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

[diff] [blame]

2883

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2888

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

2889

}

2890

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2891

{

2892

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

2893

// If not, use the default value.

2894

if (VOS_STATUS_SUCCESS == match_status)

2895

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2896

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

2897

if (rv < 0) {

2898

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

2899

__func__, pRegEntry->RegName);

2900

svalue = (v_S31_t)pRegEntry->VarDefault;

2901

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2906

}

2907

2908

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

2909

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2910

{

2911

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

2912

{

2913

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2914

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

Jeff Johnson

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

[diff] [blame]

2915

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

2916

svalue = (v_S31_t)pRegEntry->VarMax;

2917

}

2918

2919

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

2920

{

2921

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2922

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

Jeff Johnson

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

[diff] [blame]

2923

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

2924

svalue = (v_S31_t)pRegEntry->VarMin;

2925

}

2926

}

2927

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

2928

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2929

{

2930

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

2931

{

2932

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

2933

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2934

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2935

(int)pRegEntry->VarMax,

2936

(int)pRegEntry->VarDefault );

2937

svalue = (v_S31_t)pRegEntry->VarDefault;

2938

}

2939

2940

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

2941

{

2942

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

2943

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2944

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2945

(int)pRegEntry->VarMin,

2946

(int)pRegEntry->VarDefault);

2947

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2952

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

2953

}

2954

// Handle string parameters

2955

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2956

{

2957

#ifdef WLAN_CFG_DEBUG

2958

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2959

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

Jeff Johnson

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

[diff] [blame]

2960

#endif

2961

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2962

if ( match_status == VOS_STATUS_SUCCESS)

Jeff Johnson

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

[diff] [blame]

2963

{

2964

len_value_str = strlen(value_str);

2965

2966

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2967

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]

2968

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

Jeff Johnson

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

[diff] [blame]

2969

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

2970

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

2971

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

}

else

{

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

2976

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

2977

}

2978

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2979

else

Jeff Johnson

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

[diff] [blame]

2980

{

2981

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

2982

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

2983

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2984

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

Jeff Johnson

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

[diff] [blame]

2985

}

2986

}

2987

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2988

{

2989

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2990

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

2991

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

Jeff Johnson

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

[diff] [blame]

2992

continue;

2993

}

2994

candidate = (char*)pRegEntry->VarDefault;

2995

if ( match_status == VOS_STATUS_SUCCESS) {

2996

len_value_str = strlen(value_str);

2997

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

2998

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]

2999

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

Jeff Johnson

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

[diff] [blame]

3000

}

3001

else

3002

candidate = value_str;

3003

}

3004

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

3005

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

3006

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3007

((char*)pField)[i] =

3008

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

Jeff Johnson

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

[diff] [blame]

}

}

else

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3013

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]

3014

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3015

}

3016

3017

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

3018

if( (match_status == VOS_STATUS_SUCCESS) &&

3019

(idx < MAX_CFG_INI_ITEMS) )

3020

{

3021

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

}

}

print_hdd_cfg(pHddCtx);

3026

3027

return( ret_status );

3028

}

3029

3030

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

3031

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3032

switch (dot11Mode)

Jeff Johnson

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

[diff] [blame]

3033

{

3034

case (eHDD_DOT11_MODE_abg):

3035

return eCSR_DOT11_MODE_abg;

3036

case (eHDD_DOT11_MODE_11b):

3037

return eCSR_DOT11_MODE_11b;

3038

case (eHDD_DOT11_MODE_11g):

3039

return eCSR_DOT11_MODE_11g;

3040

default:

3041

case (eHDD_DOT11_MODE_11n):

3042

return eCSR_DOT11_MODE_11n;

3043

case (eHDD_DOT11_MODE_11g_ONLY):

3044

return eCSR_DOT11_MODE_11g_ONLY;

3045

case (eHDD_DOT11_MODE_11n_ONLY):

3046

return eCSR_DOT11_MODE_11n_ONLY;

3047

case (eHDD_DOT11_MODE_11b_ONLY):

3048

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

3049

#ifdef WLAN_FEATURE_11AC

3050

case (eHDD_DOT11_MODE_11ac_ONLY):

3051

return eCSR_DOT11_MODE_11ac_ONLY;

3052

case (eHDD_DOT11_MODE_11ac):

3053

return eCSR_DOT11_MODE_11ac;

3054

#endif

Jeff Johnson

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

[diff] [blame]

3055

case (eHDD_DOT11_MODE_AUTO):

3056

return eCSR_DOT11_MODE_AUTO;

}

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3061

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

Jeff Johnson

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

[diff] [blame]

3062

{

3063

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3064

tSmeBtcConfig btcParams;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3065

Jeff Johnson

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

[diff] [blame]

3066

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

3067

3068

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

3069

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

3070

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

3071

Jeff Johnson

32d95a3

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

[diff] [blame]

3072

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

3073

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

3074

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

3075

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

3076

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

3077

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

3078

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

3079

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

3080

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

3081

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

3082

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

3083

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

3084

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

3085

Jeff Johnson

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

[diff] [blame]

3086

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

3087

}

3088

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3089

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

Jeff Johnson

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

[diff] [blame]

3090

{

3091

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3092

3093

tPmcBmpsConfigParams bmpsParams;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3094

Jeff Johnson

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

[diff] [blame]

3095

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3096

Jeff Johnson

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

[diff] [blame]

3097

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

3098

{

3099

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

3100

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

3101

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3102

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3103

}

3104

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

3105

{

3106

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

3107

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

3108

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3109

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3110

}

3111

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

3112

{

3113

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

3114

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

3115

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3116

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3117

}

3118

3119

if (pConfig->fIsImpsEnabled)

3120

{

3121

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

3126

}

3127

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

3128

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

3129

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

3130

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

3131

Jeff Johnson

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

[diff] [blame]

3132

if (pConfig->fIsBmpsEnabled)

3133

{

3134

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

3139

}

3140

3141

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

3142

3143

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

3144

{

3145

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

3146

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3147

Jeff Johnson

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

[diff] [blame]

3148

if(pConfig->fIsAutoBmpsTimerEnabled)

3149

{

3150

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3156

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 )

3161

{

3162

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

3166

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

3167

{

3168

int val;

3169

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

3170

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

3171

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

3172

{

3173

intArray[*len] = (tANI_U8) val;

3174

*len += 1;

3175

}

3176

s = strpbrk( s, "," );

3177

if( s )

3178

s++;

3179

}

Jeff Johnson

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

[diff] [blame]

3180

3181

return VOS_STATUS_SUCCESS;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3182

Jeff Johnson

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

[diff] [blame]

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

3188

{

3189

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

3190

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3191

tANI_U32 val;

3192

#endif

Jeff Johnson

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

[diff] [blame]

3193

3194

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

3195

tSirMacHTCapabilityInfo htCapInfo;

3196

Jeff Johnson

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

[diff] [blame]

3197

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3198

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

Jeff Johnson

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

[diff] [blame]

3199

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

3200

{

3201

fStatus = FALSE;

3202

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

3203

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3204

3205

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

Jeff Johnson

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

[diff] [blame]

3206

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3207

{

3208

fStatus = FALSE;

3209

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

3210

}

3211

3212

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

3213

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3214

{

3215

fStatus = FALSE;

3216

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

3217

}

3218

3219

if ( 0 != pConfig->Cfg1Id )

3220

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3221

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

Jeff Johnson

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

[diff] [blame]

3222

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3223

{

3224

fStatus = FALSE;

3225

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

3226

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3227

Jeff Johnson

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

[diff] [blame]

3228

}

3229

3230

if ( 0 != pConfig->Cfg2Id )

3231

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3232

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

Jeff Johnson

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

[diff] [blame]

3233

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3234

{

3235

fStatus = FALSE;

3236

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

}

}

if ( 0 != pConfig->Cfg3Id )

3241

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3242

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

Jeff Johnson

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

[diff] [blame]

3243

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3244

{

3245

fStatus = FALSE;

3246

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

}

}

if ( 0 != pConfig->Cfg4Id )

3251

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3252

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

Jeff Johnson

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

[diff] [blame]

3253

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3254

{

3255

fStatus = FALSE;

3256

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

}

}

if ( 0 != pConfig->Cfg5Id )

3261

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3262

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

Jeff Johnson

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

[diff] [blame]

3263

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3264

{

3265

fStatus = FALSE;

3266

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

}

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3270

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

Jeff Johnson

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

[diff] [blame]

3271

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3272

{

3273

fStatus = FALSE;

3274

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

3275

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3276

3277

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

Jeff Johnson

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

[diff] [blame]

3278

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3279

{

3280

fStatus = FALSE;

3281

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

3282

}

3283

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3284

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

Jeff Johnson

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

[diff] [blame]

3285

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

3286

{

3287

fStatus = FALSE;

3288

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

3289

}

3290

3291

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

3292

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3293

{

3294

fStatus = FALSE;

3295

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

3296

}

3297

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3298

if (pConfig->fIsAutoIbssBssid)

Jeff Johnson

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

[diff] [blame]

3299

{

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3300

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

Jeff Johnson

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

[diff] [blame]

3301

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

3302

{

3303

fStatus = FALSE;

3304

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

3305

}

3306

}

3307

else

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3308

{

Jeff Johnson

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

[diff] [blame]

3309

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

3310

{

3311

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3312

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3313

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

Jeff Johnson

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

[diff] [blame]

3314

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3315

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

Jeff Johnson

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

[diff] [blame]

3316

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

3317

{

3318

fStatus = FALSE;

3319

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

}

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3329

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

Jeff Johnson

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

[diff] [blame]

3330

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3331

{

3332

fStatus = FALSE;

3333

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

3334

}

3335

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3336

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

Jeff Johnson

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

[diff] [blame]

3337

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3338

{

3339

fStatus = FALSE;

3340

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

3341

}

3342

3343

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

3344

{

3345

fStatus = FALSE;

3346

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

3347

}

3348

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3349

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

Jeff Johnson

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

[diff] [blame]

3350

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3351

{

3352

fStatus = FALSE;

3353

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

3354

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3355

Jeff Johnson

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

[diff] [blame]

3356

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

3357

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3358

{

3359

fStatus = FALSE;

3360

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

3361

}

3362

Jeff Johnson

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

[diff] [blame]

3363

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

3364

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3365

{

3366

fStatus = FALSE;

3367

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

3368

}

3369

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3370

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

Jeff Johnson

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

[diff] [blame]

3371

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3372

{

3373

fStatus = FALSE;

3374

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

3375

}

3376

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3377

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

Jeff Johnson

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

[diff] [blame]

3378

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3379

{

3380

fStatus = FALSE;

3381

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

3382

}

3383

Gopichand Nakkala

98a98af

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

[diff] [blame]

3384

#ifdef FEATURE_WLAN_LFR

3385

if (pConfig->isFastRoamIniFeatureEnabled)

3386

{

3387

pConfig->fEnableFwRssiMonitoring = TRUE;

3388

}

3389

#endif

3390

#ifdef FEATURE_WLAN_CCX

3391

if (pConfig->isCcxIniFeatureEnabled)

3392

{

3393

pConfig->fEnableFwRssiMonitoring = TRUE;

3394

}

3395

#endif

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3396

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

Jeff Johnson

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

[diff] [blame]

3397

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3398

{

3399

fStatus = FALSE;

3400

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

3401

}

3402

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3403

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

Jeff Johnson

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

[diff] [blame]

3404

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3405

{

3406

fStatus = FALSE;

3407

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

3408

}

3409

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3410

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

Jeff Johnson

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

[diff] [blame]

3411

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3412

{

3413

fStatus = FALSE;

3414

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

3415

}

3416

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3417

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

Jeff Johnson

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

[diff] [blame]

3418

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3419

{

3420

fStatus = FALSE;

3421

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

3422

}

3423

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3424

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

Jeff Johnson

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

[diff] [blame]

3425

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3426

{

3427

fStatus = FALSE;

3428

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

3429

}

3430

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3431

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

Jeff Johnson

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

[diff] [blame]

3432

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3433

{

3434

fStatus = FALSE;

3435

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3436

}

Jeff Johnson

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

[diff] [blame]

3437

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3438

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

Jeff Johnson

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

[diff] [blame]

3439

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3440

{

3441

fStatus = FALSE;

3442

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

3443

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3444

Sejal Chauhan

bcde8bc

2013-03-04 18:06:36 +0530

[diff] [blame]

3445

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_AP_LINK_MONITOR_TIMEOUT, pConfig->apLinkMonitorPeriod,

3446

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3447

{

3448

fStatus = FALSE;

3449

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

3450

}

3451

Jeff Johnson

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

[diff] [blame]

3452

#if defined WLAN_FEATURE_VOWIFI

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3453

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

Jeff Johnson

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

[diff] [blame]

3454

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3455

{

3456

fStatus = FALSE;

3457

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

3458

}

3459

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3460

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

Jeff Johnson

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

[diff] [blame]

3461

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3462

{

3463

fStatus = FALSE;

3464

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

3465

}

3466

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3467

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

Jeff Johnson

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

[diff] [blame]

3468

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3469

{

3470

fStatus = FALSE;

3471

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

3472

}

3473

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3474

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

Jeff Johnson

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

[diff] [blame]

3475

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3476

#endif

3477

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3478

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

Jeff Johnson

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

[diff] [blame]

3479

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3480

{

3481

fStatus = FALSE;

3482

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

3483

}

3484

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3485

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

Jeff Johnson

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

[diff] [blame]

3486

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3487

{

3488

fStatus = FALSE;

3489

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

3490

}

3491

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3492

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

Jeff Johnson

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

[diff] [blame]

3493

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3494

{

3495

fStatus = FALSE;

3496

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

3497

}

3498

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3499

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

Jeff Johnson

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

[diff] [blame]

3500

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3501

{

3502

fStatus = FALSE;

3503

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

3504

}

3505

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3506

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

Jeff Johnson

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

[diff] [blame]

3507

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3508

{

3509

fStatus = FALSE;

3510

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

3511

}

3512

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3513

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

Jeff Johnson

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

[diff] [blame]

3514

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3515

{

3516

fStatus = FALSE;

3517

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

3518

}

3519

3520

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

3521

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3522

{

3523

fStatus = FALSE;

3524

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

3525

}

3526

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3527

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

Jeff Johnson

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

[diff] [blame]

3528

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3529

{

3530

fStatus = FALSE;

3531

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

3532

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3533

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

Jeff Johnson

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

[diff] [blame]

3534

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3535

{

3536

fStatus = FALSE;

3537

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

3538

}

3539

3540

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

3541

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3542

{

3543

fStatus = FALSE;

3544

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3545

}

Jeff Johnson

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

[diff] [blame]

3546

Jeff Johnson

eed2dca

2013-02-22 21:18:46 -0800

[diff] [blame]

3547

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

Jeff Johnson

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

[diff] [blame]

3548

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

Jeff Johnson

eed2dca

2013-02-22 21:18:46 -0800

[diff] [blame]

3549

{

3550

fStatus = FALSE;

3551

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

3552

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3553

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

Jeff Johnson

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

[diff] [blame]

3554

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3555

{

3556

fStatus = FALSE;

3557

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

3558

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3559

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

Jeff Johnson

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

[diff] [blame]

3560

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3561

{

3562

fStatus = FALSE;

3563

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

3564

}

3565

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3566

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

Jeff Johnson

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

[diff] [blame]

3567

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3568

{

3569

fStatus = FALSE;

3570

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

3571

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3572

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

Jeff Johnson

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

[diff] [blame]

3573

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3574

{

3575

fStatus = FALSE;

3576

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

3577

}

3578

Jeff Johnson

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

[diff] [blame]

3579

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

3580

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3581

{

3582

fStatus = FALSE;

3583

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

3584

}

3585

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3586

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

Jeff Johnson

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

[diff] [blame]

3587

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3588

==eHAL_STATUS_FAILURE)

3589

{

3590

fStatus = FALSE;

3591

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

3592

}

3593

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3594

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

Jeff Johnson

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

[diff] [blame]

3595

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3596

==eHAL_STATUS_FAILURE)

3597

{

3598

fStatus = FALSE;

3599

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

3600

}

3601

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3602

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

Jeff Johnson

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

[diff] [blame]

3603

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

3604

{

3605

fStatus = FALSE;

3606

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

3607

}

3608

Jeff Johnson

d13512a

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

[diff] [blame]

3609

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3610

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

Jeff Johnson

d13512a

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

[diff] [blame]

3611

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3612

{

3613

fStatus = FALSE;

3614

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

3615

}

3616

Jeff Johnson

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

[diff] [blame]

3617

#ifdef WLAN_FEATURE_11AC

3618

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

3619

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

3620

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

3621

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

3622

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3623

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3629

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

Jeff Johnson

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

[diff] [blame]

3630

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3631

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

Jeff Johnson

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

[diff] [blame]

3632

temp, NULL, eANI_BOOLEAN_FALSE)

3633

==eHAL_STATUS_FAILURE)

3634

{

3635

fStatus = FALSE;

3636

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

3637

}

3638

3639

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3640

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

Jeff Johnson

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

[diff] [blame]

3641

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3642

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

3643

temp, NULL, eANI_BOOLEAN_FALSE)

3644

==eHAL_STATUS_FAILURE)

3645

{

3646

fStatus = FALSE;

3647

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

3648

}

3649

3650

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3651

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

Jeff Johnson

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

[diff] [blame]

3652

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3653

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

3654

temp, NULL, eANI_BOOLEAN_FALSE)

3655

==eHAL_STATUS_FAILURE)

3656

{

3657

fStatus = FALSE;

3658

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

}

}

}

#endif

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3664

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

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

3665

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3666

{

3667

fStatus = FALSE;

3668

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

3669

}

3670

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3671

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

Pratik Bhalgat

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

[diff] [blame]

3672

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3673

==eHAL_STATUS_FAILURE)

3674

{

3675

fStatus = FALSE;

3676

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

3677

}

3678

3679

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

3680

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3681

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3682

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

Pratik Bhalgat

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

[diff] [blame]

3683

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

3684

==eHAL_STATUS_FAILURE)

3685

{

3686

fStatus = FALSE;

3687

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

3688

}

3689

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3690

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

Pratik Bhalgat

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

[diff] [blame]

3691

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3692

==eHAL_STATUS_FAILURE)

3693

{

3694

fStatus = FALSE;

3695

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

3696

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3697

3698

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3699

if(pConfig->fEnableVSTASupport)

3700

{

3701

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

3702

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3703

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3708

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3709

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

Gopichand Nakkala

976e325

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

[diff] [blame]

3710

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3711

{

3712

fStatus = FALSE;

3713

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

3714

}

3715

#endif

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3716

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3717

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3718

==eHAL_STATUS_FAILURE)

3719

{

3720

fStatus = FALSE;

3721

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

3722

}

Pratik Bhalgat

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

[diff] [blame]

3723

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3724

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

3725

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3726

{

3727

fStatus = FALSE;

3728

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

3729

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

3730

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

3731

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3732

{

3733

fStatus = FALSE;

Kiran Kumar Lokere

1f39e95

2013-04-03 18:34:30 -0700

[diff] [blame]

3734

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

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

3735

}

Kiran Kumar Lokere

1f39e95

2013-04-03 18:34:30 -0700

[diff] [blame]

3736

3737

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DYNAMIC_THRESHOLD_ZERO, pConfig->retryLimitZero,

3738

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3739

{

3740

fStatus = FALSE;

3741

hddLog(LOGE, "Could not pass on WNI_CFG_DYNAMIC_THRESHOLD_ZERO to CCM");

3742

}

3743

3744

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DYNAMIC_THRESHOLD_ONE, pConfig->retryLimitOne,

3745

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3746

{

3747

fStatus = FALSE;

3748

hddLog(LOGE, "Could not pass on WNI_CFG_DYNAMIC_THRESHOLD_ONE to CCM");

3749

}

3750

3751

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_DYNAMIC_THRESHOLD_TWO, pConfig->retryLimitTwo,

3752

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3753

{

3754

fStatus = FALSE;

3755

hddLog(LOGE, "Could not pass on WNI_CFG_DYNAMIC_THRESHOLD_TWO to CCM");

3756

}

3757

Gopichand Nakkala

42bc89e

2013-05-27 12:49:09 +0530

[diff] [blame]

3758

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_MEDIUM_TIME, pConfig->cfgMaxMediumTime,

3759

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3760

{

3761

fStatus = FALSE;

3762

hddLog(LOGE, "Could not pass on WNI_CFG_MAX_MEDIUM_TIME to CCM");

3763

}

3764

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3770

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3771

\brief hdd_init_set_sme_config() -

Jeff Johnson

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

[diff] [blame]

3772

3773

This function initializes the sme configuration parameters

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3774

Jeff Johnson

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

[diff] [blame]

3775

\param - pHddCtx - Pointer to the HDD Adapter.

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3776

Jeff Johnson

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

[diff] [blame]

3777

\return - 0 for success, non zero for failure

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3778

Jeff Johnson

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

[diff] [blame]

3779

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

3780

3781

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3782

{

3783

VOS_STATUS status = VOS_STATUS_SUCCESS;

3784

eHalStatus halStatus;

3785

tSmeConfigParams smeConfig;

3786

3787

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3788

3789

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3790

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3791

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

Jeff Johnson

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

[diff] [blame]

3792

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

3793

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

3794

3795

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3796

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3797

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

Jeff Johnson

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

[diff] [blame]

3798

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3799

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3800

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3801

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3802

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3803

3804

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

3805

3806

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3807

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3808

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3809

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3810

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3811

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3812

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3813

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3814

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3815

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3816

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3817

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3818

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3819

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3820

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3821

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3822

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3823

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

Jeff Johnson

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

[diff] [blame]

3824

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3825

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3826

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3827

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3828

smeConfig.csrConfig.nActiveMaxChnTimeBtc = pConfig->nActiveMaxChnTimeBtc;

3829

smeConfig.csrConfig.nActiveMinChnTimeBtc = pConfig->nActiveMinChnTimeBtc;

Kiran Kumar Lokere

458d732

2013-05-29 14:29:43 -0700

[diff] [blame^]

3830

smeConfig.csrConfig.disableAggWithBtc = pConfig->disableAggWithBtc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3831

#ifdef WLAN_AP_STA_CONCURRENCY

3832

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3833

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3834

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3835

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3836

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Sudhir Sattayappa Kohalli

eb97d50

2013-05-22 23:16:42 -0700

[diff] [blame]

3837

smeConfig.csrConfig.nNumStaChanCombinedConc = pConfig->nNumStaChanCombinedConc;

3838

smeConfig.csrConfig.nNumP2PChanCombinedConc = pConfig->nNumP2PChanCombinedConc;

3839

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3840

#endif

Jeff Johnson

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

[diff] [blame]

3841

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3842

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3843

3844

#if defined WLAN_FEATURE_VOWIFI

3845

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3846

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3847

#endif

3848

//Remaining config params not obtained from registry

3849

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3850

#ifdef WLAN_FEATURE_11AC

3851

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

3852

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

3853

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Jeff Johnson

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

[diff] [blame]

3854

#endif

Shailender Karmuchi

a734f33

2013-04-19 14:02:48 -0700

[diff] [blame]

3855

smeConfig.csrConfig.AdHocChannel5G = pConfig->AdHocChannel5G;

3856

smeConfig.csrConfig.AdHocChannel24 = pConfig->AdHocChannel24G;

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3857

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3858

smeConfig.csrConfig.HeartbeatThresh50 = 40;

3859

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3860

if (pConfig->nBandCapability == eCSR_BAND_24)

3861

{

3862

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3863

} else {

3864

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3865

}

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3866

smeConfig.csrConfig.cbChoice = 0;

3867

smeConfig.csrConfig.bgScanInterval = 0;

3868

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

Jeff Johnson

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

[diff] [blame]

3869

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3870

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3871

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3872

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

3873

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

Srinivas Girigowda

bbd16eb

2013-03-21 12:34:46 -0700

[diff] [blame]

3874

smeConfig.csrConfig.nRoamIntraBand = pConfig->nRoamIntraBand;

Varun Reddy Yeturu

920df21

2013-05-22 08:07:23 -0700

[diff] [blame]

3875

smeConfig.csrConfig.nProbes = pConfig->nProbes;

3876

smeConfig.csrConfig.nRoamScanHomeAwayTime = pConfig->nRoamScanHomeAwayTime;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3877

#endif

Jeff Johnson

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

[diff] [blame]

3878

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3879

Jeff Johnson

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

[diff] [blame]

3880

//FIXME 11d config is hardcoded

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

3881

if ( VOS_STA_SAP_MODE != hdd_get_conparam())

3882

{

3883

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

Jeff Johnson

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

[diff] [blame]

3884

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

3885

/* if there is a requirement that HDD will control the default

3886

* channel list & country code (say from .ini file) we need to

3887

* add some logic here. Otherwise the default 11d info should

3888

* come from NV as per our current implementation */

Jeff Johnson

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

[diff] [blame]

3889

}

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

3890

else

3891

{

3892

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3893

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

Jeff Johnson

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

[diff] [blame]

3894

Jeff Johnson

2013-02-27 08:36:13 -0800

[diff] [blame]

3895

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

3896

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

3897

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3898

}

Jeff Johnson

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

[diff] [blame]

3899

hdd_set_power_save_config(pHddCtx, &smeConfig);

3900

hdd_set_btc_config(pHddCtx);

3901

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3902

#ifdef WLAN_FEATURE_VOWIFI_11R

Jeff Johnson

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

[diff] [blame]

3903

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

3904

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3905

#ifdef FEATURE_WLAN_LFR

3906

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3907

if( pConfig->isFastRoamIniFeatureEnabled )

3908

{

3909

pConfig->isFastTransitionEnabled = TRUE;

3910

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

3911

#endif

Jeff Johnson

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

[diff] [blame]

3912

#ifdef FEATURE_WLAN_CCX

3913

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3914

if( pConfig->isCcxIniFeatureEnabled )

3915

{

3916

pConfig->isFastTransitionEnabled = TRUE;

3917

}

Jeff Johnson

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

[diff] [blame]

3918

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3919

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

3920

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3921

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3922

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Srinivas Girigowda

100eb32

2013-03-15 16:48:20 -0700

[diff] [blame]

3923

smeConfig.csrConfig.isWESModeEnabled = pConfig->isWESModeEnabled;

Jeff Johnson

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

[diff] [blame]

3924

#endif

Varun Reddy Yeturu

d0a3f25

2013-04-15 21:58:13 -0700

[diff] [blame]

3925

#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD

3926

smeConfig.csrConfig.isRoamOffloadScanEnabled = pConfig->isRoamOffloadScanEnabled;

3927

#endif

Jeff Johnson

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

[diff] [blame]

3928

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3929

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

3930

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3931

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

3932

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

Jeff Johnson

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

[diff] [blame]

3933

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3934

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

Jeff Johnson

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

[diff] [blame]

3935

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

Srinivas Girigowda

de69741

2013-02-14 16:31:48 -0800

[diff] [blame]

3936

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

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3937

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3938

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3939

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

Jeff Johnson

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

[diff] [blame]

3940

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3941

#endif

3942

3943

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3944

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3945

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3946

//Enable/Disable MCC

Jeff Johnson

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

[diff] [blame]

3947

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3948

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3949

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

3950

//Scan Results Aging Time out value

3951

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3952

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

3953

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

3954

Gopichand Nakkala

e620d5a

2013-04-26 05:45:57 -0700

[diff] [blame]

3955

/* update SSR config */

3956

sme_UpdateEnableSSR((tHalHandle)(pHddCtx->hHal), pHddCtx->cfg_ini->enableSSR);

3957

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3958

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

Jeff Johnson

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

[diff] [blame]

3959

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3960

{

3961

status = VOS_STATUS_E_FAILURE;

3962

}

3963

Kiran Kumar Lokere

2013-02-24 22:21:28 -0800

[diff] [blame]

3964

3965

return status;

Jeff Johnson

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

[diff] [blame]

}

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

3970

3971

\brief hdd_execute_config_command() -

3972

3973

This function executes an arbitrary configuration set command

3974

3975

\param - pHddCtx - Pointer to the HDD Adapter.

3976

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

3977

3978

3979

\return - 0 for success, non zero for failure

3980

3981

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

3982

3983

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3984

{

3985

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

3986

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;

3995

unsigned int idx;

3996

unsigned int i;

3997

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3998

int rv;

Jeff Johnson

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

[diff] [blame]

3999

4000

// assume failure until proven otherwise

4001

vstatus = VOS_STATUS_E_FAILURE;

4002

4003

// clone the command so that we can manipulate it

4004

clone = kstrdup(command, GFP_ATOMIC);

4005

if (NULL == clone)

4006

{

4007

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4008

__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

4013

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

4014

pCmd = clone;

4015

4016

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

4022

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

4027

name = pCmd;

4028

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]

4036

__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

4046

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4047

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

4052

if ('\0' == *value_str)

4053

{

4054

// did not find a value

4055

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4056

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

4061

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

4062

{

4063

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

{

// found a match

break;

}

}

if (tableSize == idx)

4070

{

4071

// did not match the name

4072

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4073

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

4078

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

4079

{

4080

// does not support dynamic configuration

4081

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4082

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

4087

4088

switch (pRegEntry->RegType)

4089

{

4090

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4091

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

4092

if (rv < 0)

4093

goto done;

Jeff Johnson

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

[diff] [blame]

4094

if (value < pRegEntry->VarMin)

4095

{

4096

// out of range

4097

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4098

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4099

goto done;

4100

}

4101

if (value > pRegEntry->VarMax)

4102

{

4103

// out of range

4104

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4105

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4106

goto done;

4107

}

4108

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

4109

break;

4110

4111

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4112

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

4113

if (rv < 0)

4114

goto done;

Jeff Johnson

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

[diff] [blame]

4115

if (value < pRegEntry->VarMin)

4116

{

4117

// out of range

4118

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4119

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4120

goto done;

4121

}

4122

if (value > pRegEntry->VarMax)

4123

{

4124

// out of range

4125

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4126

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4127

goto done;

4128

}

4129

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

4130

break;

4131

4132

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4133

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

4134

if (rv < 0)

4135

goto done;

Jeff Johnson

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

[diff] [blame]

4136

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

4137

{

4138

// out of range

4139

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4140

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

Jeff Johnson

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

[diff] [blame]

4141

goto done;

4142

}

4143

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

4144

{

4145

// out of range

4146

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4147

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

Jeff Johnson

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

[diff] [blame]

4148

goto done;

4149

}

4150

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

4151

break;

4152

4153

case WLAN_PARAM_String:

4154

len_value_str = strlen(value_str);

4155

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

{

// too big

hddLog(LOGE,

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

4160

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4161

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

4162

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

4163

goto done;

4164

}

4165

// copy string plus NUL

4166

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

4167

break;

4168

4169

case WLAN_PARAM_MacAddr:

4170

len_value_str = strlen(value_str);

4171

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

4176

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4177

__func__, value_str,

Jeff Johnson