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

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

[diff] [blame]

2692

#endif

2693

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

2694

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

2695

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

2696

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

2697

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

2698

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

2699

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

2700

2701

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

2702

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

2703

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

2704

#ifdef WLAN_BTAMP_FEATURE

2705

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

2706

#endif //WLAN_BTAMP_FEATURE

2707

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

2708

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

2709

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

2710

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

2711

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

2712

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

2713

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

2714

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

2715

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

2716

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

2717

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

2718

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

2719

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]

2720

#ifdef WLAN_FEATURE_11AC

2721

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

2722

#endif

2723

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

2724

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

2725

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]

2726

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]

2727

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

Gopichand Nakkala

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

[diff] [blame]

2728

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

Ravi Joshi

83bfaa1

2013-05-28 22:12:08 -0700

[diff] [blame]

2729

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

Gopichand Nakkala

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

[diff] [blame]

2730

Leo Chang

64d68bc

2013-06-04 15:40:52 -0700

[diff] [blame]

2731

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

2732

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

Jeff Johnson

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

[diff] [blame]

}

Gopichand Nakkala

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

[diff] [blame]

2736

Jeff Johnson

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

[diff] [blame]

2737

#define CFG_VALUE_MAX_LEN 256

2738

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2739

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

2740

{

2741

unsigned int idx;

2742

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2743

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

2744

v_U32_t value;

2745

char valueStr[CFG_VALUE_MAX_LEN];

2746

char configStr[CFG_ENTRY_MAX_LEN];

2747

char *fmt;

2748

void *pField;

2749

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2754

*pCur = '\0';

2755

Kiran Kumar Lokere

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

[diff] [blame]

2756

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

Jeff Johnson

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

[diff] [blame]

2757

{

2758

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

2759

2760

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

2761

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

Kiran Kumar Lokere

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

[diff] [blame]

2762

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

Jeff Johnson

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

[diff] [blame]

2763

{

2764

value = 0;

2765

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

2766

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

2779

}

2780

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2781

{

2782

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

2783

}

2784

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2785

{

2786

pMacAddr = (v_MACADDR_t *) pField;

2787

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2788

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

2799

}

2800

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2805

"*" : "");

2806

2807

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

2808

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

2809

#ifdef RETURN_IN_BUFFER

2810

if (curlen <= buflen)

2811

{

2812

// copy string + '\0'

2813

memcpy(pCur, configStr, curlen+1);

2814

2815

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2822

return VOS_STATUS_E_RESOURCES;

2823

}

2824

#else

2825

printk(KERN_CRIT "%s", configStr);

2826

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2831

// notify application that output is in system log

2832

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

2833

#endif // RETURN_IN_BUFFER

2834

2835

return VOS_STATUS_SUCCESS;

2836

}

2837

2838

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

Kiran Kumar Lokere

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

[diff] [blame]

2839

char *name, char** value)

Jeff Johnson

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

[diff] [blame]

2840

{

2841

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2842

unsigned long i;

2843

2844

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

2845

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

2846

*value = iniTable[i].value;

2847

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

2848

WLAN_INI_FILE, name, *value);

2849

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2857

{

2858

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

2859

return c-'0';

2860

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

2861

return c-'a'+10;

2862

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)

2870

{

2871

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2872

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2873

unsigned int idx;

2874

void *pField;

2875

char *value_str = NULL;

2876

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2881

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2882

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

2883

v_U32_t cbOutString;

2884

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2885

int rv;

Jeff Johnson

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

[diff] [blame]

2886

2887

// sanity test

2888

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2889

{

2890

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]

2891

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2892

}

2893

2894

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

2895

{

2896

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

2897

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

2898

2899

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

2900

2901

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

2902

{

2903

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

2904

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2905

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2906

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2911

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2912

{

2913

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

2914

// If not, use the default value.

2915

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2916

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

2917

if (rv < 0) {

2918

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

2919

__func__, pRegEntry->RegName);

2920

value = pRegEntry->VarDefault;

2921

}

Jeff Johnson

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

[diff] [blame]

2922

}

2923

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2924

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

2925

if (rv < 0) {

2926

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

2927

__func__, pRegEntry->RegName);

2928

value = pRegEntry->VarDefault;

2929

}

Jeff Johnson

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

[diff] [blame]

2930

}

2931

else {

2932

value = pRegEntry->VarDefault;

2933

}

2934

2935

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

2936

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2937

{

2938

if ( value > pRegEntry->VarMax )

2939

{

2940

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2941

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

Jeff Johnson

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

[diff] [blame]

2942

value = pRegEntry->VarMax;

2943

}

2944

2945

if ( value < pRegEntry->VarMin )

2946

{

2947

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2948

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

Jeff Johnson

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

[diff] [blame]

2949

value = pRegEntry->VarMin;

2950

}

2951

}

2952

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

2953

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2954

{

2955

if ( value > pRegEntry->VarMax )

2956

{

2957

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]

2958

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

Jeff Johnson

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

[diff] [blame]

2959

value = pRegEntry->VarDefault;

2960

}

2961

2962

if ( value < pRegEntry->VarMin )

2963

{

2964

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]

2965

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

Jeff Johnson

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

[diff] [blame]

2966

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2971

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

2972

}

2973

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2974

{

2975

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

2976

// If not, use the default value.

2977

if (VOS_STATUS_SUCCESS == match_status)

2978

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2979

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

2980

if (rv < 0) {

2981

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

2982

__func__, pRegEntry->RegName);

2983

svalue = (v_S31_t)pRegEntry->VarDefault;

2984

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2989

}

2990

2991

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

2992

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2993

{

2994

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

2995

{

2996

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2997

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

Jeff Johnson

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

[diff] [blame]

2998

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

2999

svalue = (v_S31_t)pRegEntry->VarMax;

3000

}

3001

3002

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

3003

{

3004

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3005

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

Jeff Johnson

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

[diff] [blame]

3006

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

3007

svalue = (v_S31_t)pRegEntry->VarMin;

3008

}

3009

}

3010

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

3011

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3012

{

3013

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

3014

{

3015

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

3016

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3017

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3018

(int)pRegEntry->VarMax,

3019

(int)pRegEntry->VarDefault );

3020

svalue = (v_S31_t)pRegEntry->VarDefault;

3021

}

3022

3023

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

3024

{

3025

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

3026

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3027

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3028

(int)pRegEntry->VarMin,

3029

(int)pRegEntry->VarDefault);

3030

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3035

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

3036

}

3037

// Handle string parameters

3038

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3039

{

3040

#ifdef WLAN_CFG_DEBUG

3041

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]

3042

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

Jeff Johnson

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

[diff] [blame]

3043

#endif

3044

Kiran Kumar Lokere

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

[diff] [blame]

3045

if ( match_status == VOS_STATUS_SUCCESS)

Jeff Johnson

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

[diff] [blame]

3046

{

3047

len_value_str = strlen(value_str);

3048

3049

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

Kiran Kumar Lokere

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

[diff] [blame]

3050

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]

3051

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

Jeff Johnson

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

[diff] [blame]

3052

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

3053

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

3054

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

}

else

{

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

3059

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

3060

}

3061

}

Kiran Kumar Lokere

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

[diff] [blame]

3062

else

Jeff Johnson

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

[diff] [blame]

3063

{

3064

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

3065

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

3066

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

Kiran Kumar Lokere

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

[diff] [blame]

3067

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

Jeff Johnson

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

[diff] [blame]

3068

}

3069

}

3070

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3071

{

3072

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

Kiran Kumar Lokere

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

[diff] [blame]

3073

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

3074

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

Jeff Johnson

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

[diff] [blame]

3075

continue;

3076

}

3077

candidate = (char*)pRegEntry->VarDefault;

3078

if ( match_status == VOS_STATUS_SUCCESS) {

3079

len_value_str = strlen(value_str);

3080

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

Kiran Kumar Lokere

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

[diff] [blame]

3081

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]

3082

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

Jeff Johnson

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

[diff] [blame]

3083

}

3084

else

3085

candidate = value_str;

3086

}

3087

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

3088

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

3089

{

Kiran Kumar Lokere

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

[diff] [blame]

3090

((char*)pField)[i] =

3091

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

3096

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]

3097

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3098

}

3099

3100

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

3101

if( (match_status == VOS_STATUS_SUCCESS) &&

3102

(idx < MAX_CFG_INI_ITEMS) )

3103

{

3104

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

}

}

print_hdd_cfg(pHddCtx);

3109

3110

return( ret_status );

3111

}

3112

3113

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

3114

{

Kiran Kumar Lokere

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

[diff] [blame]

3115

switch (dot11Mode)

Jeff Johnson

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

[diff] [blame]

3116

{

3117

case (eHDD_DOT11_MODE_abg):

3118

return eCSR_DOT11_MODE_abg;

3119

case (eHDD_DOT11_MODE_11b):

3120

return eCSR_DOT11_MODE_11b;

3121

case (eHDD_DOT11_MODE_11g):

3122

return eCSR_DOT11_MODE_11g;

3123

default:

3124

case (eHDD_DOT11_MODE_11n):

3125

return eCSR_DOT11_MODE_11n;

3126

case (eHDD_DOT11_MODE_11g_ONLY):

3127

return eCSR_DOT11_MODE_11g_ONLY;

3128

case (eHDD_DOT11_MODE_11n_ONLY):

3129

return eCSR_DOT11_MODE_11n_ONLY;

3130

case (eHDD_DOT11_MODE_11b_ONLY):

3131

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

3132

#ifdef WLAN_FEATURE_11AC

3133

case (eHDD_DOT11_MODE_11ac_ONLY):

3134

return eCSR_DOT11_MODE_11ac_ONLY;

3135

case (eHDD_DOT11_MODE_11ac):

3136

return eCSR_DOT11_MODE_11ac;

3137

#endif

Jeff Johnson

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

[diff] [blame]

3138

case (eHDD_DOT11_MODE_AUTO):

3139

return eCSR_DOT11_MODE_AUTO;

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3144

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

Jeff Johnson

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

[diff] [blame]

3145

{

3146

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3147

tSmeBtcConfig btcParams;

Kiran Kumar Lokere

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

[diff] [blame]

3148

Jeff Johnson

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

[diff] [blame]

3149

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

3150

3151

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

3152

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

3153

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

3154

Jeff Johnson

32d95a3

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

[diff] [blame]

3155

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

3156

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

3157

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

3158

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

3159

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

3160

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

3161

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

3162

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

3163

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

3164

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

3165

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

3166

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

3167

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

3168

Jeff Johnson

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

[diff] [blame]

3169

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

3170

}

3171

Kiran Kumar Lokere

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

[diff] [blame]

3172

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

Jeff Johnson

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

[diff] [blame]

3173

{

3174

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3175

3176

tPmcBmpsConfigParams bmpsParams;

Kiran Kumar Lokere

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

[diff] [blame]

3177

Jeff Johnson

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

[diff] [blame]

3178

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

Kiran Kumar Lokere

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

[diff] [blame]

3179

Jeff Johnson

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

[diff] [blame]

3180

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

3181

{

3182

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

3183

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

3184

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3185

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3186

}

3187

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

3188

{

3189

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

3190

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

3191

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3192

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3193

}

3194

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

3195

{

3196

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

3197

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

3198

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3199

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3200

}

3201

3202

if (pConfig->fIsImpsEnabled)

3203

{

3204

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

3209

}

3210

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

3211

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

3212

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

3213

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

3214

Jeff Johnson

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

[diff] [blame]

3215

if (pConfig->fIsBmpsEnabled)

3216

{

3217

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

3222

}

3223

3224

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

3225

3226

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

3227

{

3228

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

3229

}

Kiran Kumar Lokere

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

[diff] [blame]

3230

Jeff Johnson

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

[diff] [blame]

3231

if(pConfig->fIsAutoBmpsTimerEnabled)

3232

{

3233

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3239

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 )

3244

{

3245

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

3249

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

3250

{

3251

int val;

3252

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

3253

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

3254

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

3255

{

3256

intArray[*len] = (tANI_U8) val;

3257

*len += 1;

3258

}

3259

s = strpbrk( s, "," );

3260

if( s )

3261

s++;

3262

}

Jeff Johnson

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

[diff] [blame]

3263

3264

return VOS_STATUS_SUCCESS;

Kiran Kumar Lokere

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

[diff] [blame]

3265

Jeff Johnson

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

[diff] [blame]

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

3271

{

3272

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

3273

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3274

tANI_U32 val;

3275

#endif

Jeff Johnson

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

[diff] [blame]

3276

3277

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

3278

tSirMacHTCapabilityInfo htCapInfo;

3279

Jeff Johnson

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

[diff] [blame]

3280

Kiran Kumar Lokere

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

[diff] [blame]

3281

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

Jeff Johnson

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

[diff] [blame]

3282

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

3283

{

3284

fStatus = FALSE;

3285

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

3286

}

Kiran Kumar Lokere

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

[diff] [blame]

3287

3288

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

Jeff Johnson

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

[diff] [blame]

3289

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3290

{

3291

fStatus = FALSE;

3292

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

3293

}

3294

3295

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

3296

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3297

{

3298

fStatus = FALSE;

3299

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

3300

}

3301

3302

if ( 0 != pConfig->Cfg1Id )

3303

{

Kiran Kumar Lokere

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

[diff] [blame]

3304

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

Jeff Johnson

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

[diff] [blame]

3305

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3306

{

3307

fStatus = FALSE;

3308

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

3309

}

Kiran Kumar Lokere

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

[diff] [blame]

3310

Jeff Johnson

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

[diff] [blame]

3311

}

3312

3313

if ( 0 != pConfig->Cfg2Id )

3314

{

Kiran Kumar Lokere

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

[diff] [blame]

3315

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

Jeff Johnson

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

[diff] [blame]

3316

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3317

{

3318

fStatus = FALSE;

3319

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

}

}

if ( 0 != pConfig->Cfg3Id )

3324

{

Kiran Kumar Lokere

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

[diff] [blame]

3325

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

Jeff Johnson

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

[diff] [blame]

3326

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3327

{

3328

fStatus = FALSE;

3329

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

}

}

if ( 0 != pConfig->Cfg4Id )

3334

{

Kiran Kumar Lokere

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

[diff] [blame]

3335

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

Jeff Johnson

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

[diff] [blame]

3336

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3337

{

3338

fStatus = FALSE;

3339

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

}

}

if ( 0 != pConfig->Cfg5Id )

3344

{

Kiran Kumar Lokere

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

[diff] [blame]

3345

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

Jeff Johnson

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

[diff] [blame]

3346

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3347

{

3348

fStatus = FALSE;

3349

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

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3353

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

Jeff Johnson

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

[diff] [blame]

3354

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3355

{

3356

fStatus = FALSE;

3357

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

3358

}

Kiran Kumar Lokere

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

[diff] [blame]

3359

3360

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

Jeff Johnson

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

[diff] [blame]

3361

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3362

{

3363

fStatus = FALSE;

3364

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

3365

}

3366

Kiran Kumar Lokere

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

[diff] [blame]

3367

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

Jeff Johnson

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

[diff] [blame]

3368

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

3369

{

3370

fStatus = FALSE;

3371

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

3372

}

3373

3374

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

3375

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3376

{

3377

fStatus = FALSE;

3378

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

3379

}

3380

Kiran Kumar Lokere

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

[diff] [blame]

3381

if (pConfig->fIsAutoIbssBssid)

Jeff Johnson

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

[diff] [blame]

3382

{

Kiran Kumar Lokere

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

[diff] [blame]

3383

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

Jeff Johnson

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

[diff] [blame]

3384

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

3385

{

3386

fStatus = FALSE;

3387

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

3388

}

3389

}

3390

else

Kiran Kumar Lokere

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

[diff] [blame]

3391

{

Jeff Johnson

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

[diff] [blame]

3392

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

3393

{

3394

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3395

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

3396

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

Jeff Johnson

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

[diff] [blame]

3397

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

Kiran Kumar Lokere

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

[diff] [blame]

3398

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

Jeff Johnson

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

[diff] [blame]

3399

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

3400

{

3401

fStatus = FALSE;

3402

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]

3412

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

Jeff Johnson

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

[diff] [blame]

3413

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3414

{

3415

fStatus = FALSE;

3416

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

3417

}

3418

Kiran Kumar Lokere

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

[diff] [blame]

3419

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

Jeff Johnson

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

[diff] [blame]

3420

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3421

{

3422

fStatus = FALSE;

3423

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

3424

}

3425

3426

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

3427

{

3428

fStatus = FALSE;

3429

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

3430

}

3431

Kiran Kumar Lokere

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

[diff] [blame]

3432

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

Jeff Johnson

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

[diff] [blame]

3433

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3434

{

3435

fStatus = FALSE;

3436

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

3437

}

Kiran Kumar Lokere

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

[diff] [blame]

3438

Jeff Johnson

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

[diff] [blame]

3439

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

3440

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3441

{

3442

fStatus = FALSE;

3443

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

3444

}

3445

Jeff Johnson

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

[diff] [blame]

3446

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

3447

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3448

{

3449

fStatus = FALSE;

3450

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

3451

}

3452

Kiran Kumar Lokere

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

[diff] [blame]

3453

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

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_PS_HEART_BEAT 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_PS_ENABLE_BCN_FILTER, pConfig->fEnableFwBeaconFiltering,

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_PS_BCN_FILTER configuration info to CCM\n");

3465

}

3466

Gopichand Nakkala

98a98af

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

[diff] [blame]

3467

#ifdef FEATURE_WLAN_LFR

3468

if (pConfig->isFastRoamIniFeatureEnabled)

3469

{

3470

pConfig->fEnableFwRssiMonitoring = TRUE;

3471

}

3472

#endif

3473

#ifdef FEATURE_WLAN_CCX

3474

if (pConfig->isCcxIniFeatureEnabled)

3475

{

3476

pConfig->fEnableFwRssiMonitoring = TRUE;

3477

}

3478

#endif

Kiran Kumar Lokere

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

[diff] [blame]

3479

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

Jeff Johnson

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

[diff] [blame]

3480

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3481

{

3482

fStatus = FALSE;

3483

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

3484

}

3485

Kiran Kumar Lokere

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

[diff] [blame]

3486

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

Jeff Johnson

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

[diff] [blame]

3487

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3488

{

3489

fStatus = FALSE;

3490

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

3491

}

3492

Kiran Kumar Lokere

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

[diff] [blame]

3493

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

Jeff Johnson

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

[diff] [blame]

3494

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3495

{

3496

fStatus = FALSE;

3497

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

3498

}

3499

Kiran Kumar Lokere

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

[diff] [blame]

3500

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

Jeff Johnson

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

[diff] [blame]

3501

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3502

{

3503

fStatus = FALSE;

3504

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

3505

}

3506

Kiran Kumar Lokere

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

[diff] [blame]

3507

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

Jeff Johnson

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

[diff] [blame]

3508

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3509

{

3510

fStatus = FALSE;

3511

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

3512

}

3513

Kiran Kumar Lokere

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

[diff] [blame]

3514

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

Jeff Johnson

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

[diff] [blame]

3515

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3516

{

3517

fStatus = FALSE;

3518

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]

3519

}

Jeff Johnson

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

[diff] [blame]

3520

Kiran Kumar Lokere

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

[diff] [blame]

3521

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

Jeff Johnson

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

[diff] [blame]

3522

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3523

{

3524

fStatus = FALSE;

3525

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

3526

}

Kiran Kumar Lokere

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

[diff] [blame]

3527

Sejal Chauhan

bcde8bc

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

[diff] [blame]

3528

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

3529

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3530

{

3531

fStatus = FALSE;

3532

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

3533

}

3534

Jeff Johnson

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

[diff] [blame]

3535

#if defined WLAN_FEATURE_VOWIFI

Kiran Kumar Lokere

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

[diff] [blame]

3536

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

Jeff Johnson

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

[diff] [blame]

3537

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3538

{

3539

fStatus = FALSE;

3540

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

3541

}

3542

Kiran Kumar Lokere

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

[diff] [blame]

3543

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

Jeff Johnson

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

[diff] [blame]

3544

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3545

{

3546

fStatus = FALSE;

3547

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

3548

}

3549

Kiran Kumar Lokere

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

[diff] [blame]

3550

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

Jeff Johnson

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

[diff] [blame]

3551

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3552

{

3553

fStatus = FALSE;

3554

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

3555

}

3556

Kiran Kumar Lokere

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

[diff] [blame]

3557

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

Jeff Johnson

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

[diff] [blame]

3558

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3559

#endif

3560

Kiran Kumar Lokere

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

[diff] [blame]

3561

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

Jeff Johnson

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

[diff] [blame]

3562

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3563

{

3564

fStatus = FALSE;

3565

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

3566

}

3567

Kiran Kumar Lokere

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

[diff] [blame]

3568

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

Jeff Johnson

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

[diff] [blame]

3569

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3570

{

3571

fStatus = FALSE;

3572

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

3573

}

3574

Kiran Kumar Lokere

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

[diff] [blame]

3575

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

Jeff Johnson

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

[diff] [blame]

3576

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3577

{

3578

fStatus = FALSE;

3579

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

3580

}

3581

Kiran Kumar Lokere

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

[diff] [blame]

3582

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

Jeff Johnson

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

[diff] [blame]

3583

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3584

{

3585

fStatus = FALSE;

3586

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

3587

}

3588

Kiran Kumar Lokere

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

[diff] [blame]

3589

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]

3590

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3591

{

3592

fStatus = FALSE;

3593

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

3594

}

3595

Kiran Kumar Lokere

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

[diff] [blame]

3596

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]

3597

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3598

{

3599

fStatus = FALSE;

3600

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

3601

}

3602

3603

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

3604

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3605

{

3606

fStatus = FALSE;

3607

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

3608

}

3609

Kiran Kumar Lokere

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

[diff] [blame]

3610

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

Jeff Johnson

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

[diff] [blame]

3611

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3612

{

3613

fStatus = FALSE;

3614

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

3615

}

Kiran Kumar Lokere

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

[diff] [blame]

3616

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

Jeff Johnson

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

[diff] [blame]

3617

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3618

{

3619

fStatus = FALSE;

3620

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

3621

}

3622

3623

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

3624

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3625

{

3626

fStatus = FALSE;

3627

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]

3628

}

Jeff Johnson

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

[diff] [blame]

3629

Jeff Johnson

eed2dca

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

[diff] [blame]

3630

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

Jeff Johnson

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

[diff] [blame]

3631

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

Jeff Johnson

eed2dca

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

[diff] [blame]

3632

{

3633

fStatus = FALSE;

3634

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

3635

}

Kiran Kumar Lokere

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

[diff] [blame]

3636

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

Jeff Johnson

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

[diff] [blame]

3637

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3638

{

3639

fStatus = FALSE;

3640

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

3641

}

Kiran Kumar Lokere

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

[diff] [blame]

3642

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

Jeff Johnson

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

[diff] [blame]

3643

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3644

{

3645

fStatus = FALSE;

3646

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

3647

}

3648

Kiran Kumar Lokere

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

[diff] [blame]

3649

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

Jeff Johnson

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

[diff] [blame]

3650

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3651

{

3652

fStatus = FALSE;

3653

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

3654

}

Kiran Kumar Lokere

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

[diff] [blame]

3655

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

Jeff Johnson

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

[diff] [blame]

3656

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3657

{

3658

fStatus = FALSE;

3659

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

3660

}

3661

Jeff Johnson

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

[diff] [blame]

3662

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

3663

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3664

{

3665

fStatus = FALSE;

3666

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

3667

}

3668

Kiran Kumar Lokere

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

[diff] [blame]

3669

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

Jeff Johnson

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

[diff] [blame]

3670

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3671

==eHAL_STATUS_FAILURE)

3672

{

3673

fStatus = FALSE;

3674

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

3675

}

3676

Kiran Kumar Lokere

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

[diff] [blame]

3677

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

Jeff Johnson

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

[diff] [blame]

3678

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3679

==eHAL_STATUS_FAILURE)

3680

{

3681

fStatus = FALSE;

3682

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

3683

}

3684

Kiran Kumar Lokere

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

[diff] [blame]

3685

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

Jeff Johnson

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

[diff] [blame]

3686

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

3687

{

3688

fStatus = FALSE;

3689

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

3690

}

3691

Jeff Johnson

d13512a

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

[diff] [blame]

3692

Kiran Kumar Lokere

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

[diff] [blame]

3693

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

Jeff Johnson

d13512a

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

[diff] [blame]

3694

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3695

{

3696

fStatus = FALSE;

3697

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

3698

}

3699

Jeff Johnson

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

[diff] [blame]

3700

#ifdef WLAN_FEATURE_11AC

3701

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

3702

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

3703

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

3704

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

3705

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3706

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

3712

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

Jeff Johnson

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

[diff] [blame]

3713

Kiran Kumar Lokere

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

[diff] [blame]

3714

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

Jeff Johnson

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

[diff] [blame]

3715

temp, NULL, eANI_BOOLEAN_FALSE)

3716

==eHAL_STATUS_FAILURE)

3717

{

3718

fStatus = FALSE;

3719

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

3720

}

3721

3722

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

Kiran Kumar Lokere

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

[diff] [blame]

3723

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

Jeff Johnson

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

[diff] [blame]

3724

Kiran Kumar Lokere

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

[diff] [blame]

3725

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

3726

temp, NULL, eANI_BOOLEAN_FALSE)

3727

==eHAL_STATUS_FAILURE)

3728

{

3729

fStatus = FALSE;

3730

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

3731

}

3732

3733

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

Kiran Kumar Lokere

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

[diff] [blame]

3734

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

Jeff Johnson

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

[diff] [blame]

3735

Kiran Kumar Lokere

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

[diff] [blame]

3736

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

3737

temp, NULL, eANI_BOOLEAN_FALSE)

3738

==eHAL_STATUS_FAILURE)

3739

{

3740

fStatus = FALSE;

3741

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]

3747

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

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

3748

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3749

{

3750

fStatus = FALSE;

3751

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

3752

}

3753

Kiran Kumar Lokere

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

[diff] [blame]

3754

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

Pratik Bhalgat

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

[diff] [blame]

3755

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3756

==eHAL_STATUS_FAILURE)

3757

{

3758

fStatus = FALSE;

3759

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

3760

}

3761

3762

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

3763

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3764

Kiran Kumar Lokere

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

[diff] [blame]

3765

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

Pratik Bhalgat

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

[diff] [blame]

3766

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

3767

==eHAL_STATUS_FAILURE)

3768

{

3769

fStatus = FALSE;

3770

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

3771

}

3772

Kiran Kumar Lokere

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

[diff] [blame]

3773

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

Pratik Bhalgat

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

[diff] [blame]

3774

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3775

==eHAL_STATUS_FAILURE)

3776

{

3777

fStatus = FALSE;

3778

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

3779

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3780

3781

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3782

if(pConfig->fEnableVSTASupport)

3783

{

3784

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

3785

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3786

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3791

}

Kiran Kumar Lokere

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

[diff] [blame]

3792

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

Gopichand Nakkala

976e325

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

[diff] [blame]

3793

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3794

{

3795

fStatus = FALSE;

3796

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

3797

}

3798

#endif

Kiran Kumar Lokere

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

[diff] [blame]

3799

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3800

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3801

==eHAL_STATUS_FAILURE)

3802

{

3803

fStatus = FALSE;

3804

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

3805

}

Pratik Bhalgat

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

[diff] [blame]

3806

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3807

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

3808

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3809

{

3810

fStatus = FALSE;

3811

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

3812

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

3813

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

3814

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3815

{

3816

fStatus = FALSE;

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

3817

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]

3818

}

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

3819

3820

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

3821

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3822

{

3823

fStatus = FALSE;

3824

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

3825

}

3826

3827

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

3828

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3829

{

3830

fStatus = FALSE;

3831

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

3832

}

3833

3834

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

3835

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3836

{

3837

fStatus = FALSE;

3838

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

3839

}

3840

Gopichand Nakkala

42bc89e

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

[diff] [blame]

3841

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

3842

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3843

{

3844

fStatus = FALSE;

3845

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

3846

}

3847

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3848

#ifdef FEATURE_WLAN_TDLS

3849

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3850

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,

3851

pConfig->fTDLSUapsdMask, NULL,

3852

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3853

{

3854

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3855

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

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3856

}

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3857

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_BUF_STA_ENABLED,

3858

pConfig->fEnableTDLSBufferSta, NULL,

3859

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3860

{

3861

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3862

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

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3863

}

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3864

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_PUAPSD_INACT_TIME,

3865

pConfig->fTDLSPuapsdInactivityTimer, NULL,

3866

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3867

{

3868

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3869

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

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3870

}

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3871

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,

3872

pConfig->fTDLSRxFrameThreshold, NULL,

3873

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3874

{

3875

fStatus = FALSE;

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3876

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

Gopichand Nakkala

2013-05-27 17:05:29 +0530

[diff] [blame]

3877

}

3878

#endif

3879

Sudhir Sattayappa Kohalli

2013-07-11 12:04:30 -0700

[diff] [blame]

3880

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,

3881

pConfig->fEnableAdaptRxDrain, NULL,

3882

eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3883

{

3884

fStatus = FALSE;

3885

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

3886

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3892

Kiran Kumar Lokere

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

[diff] [blame]

3893

\brief hdd_init_set_sme_config() -

Jeff Johnson

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

[diff] [blame]

3894

3895

This function initializes the sme configuration parameters

Kiran Kumar Lokere

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

[diff] [blame]

3896

Jeff Johnson

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

[diff] [blame]

3897

\param - pHddCtx - Pointer to the HDD Adapter.

Kiran Kumar Lokere

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

[diff] [blame]

3898

Jeff Johnson

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

[diff] [blame]

3899

\return - 0 for success, non zero for failure

Kiran Kumar Lokere

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

[diff] [blame]

3900

Jeff Johnson

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

[diff] [blame]

3901

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

3902

3903

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3904

{

3905

VOS_STATUS status = VOS_STATUS_SUCCESS;

3906

eHalStatus halStatus;

3907

tSmeConfigParams smeConfig;

3908

3909

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3910

3911

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3912

Kiran Kumar Lokere

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

[diff] [blame]

3913

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

Jeff Johnson

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

[diff] [blame]

3914

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

3915

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

3916

3917

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3918

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3919

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

Jeff Johnson

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

[diff] [blame]

3920

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3921

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3922

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3923

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3924

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3925

3926

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

3927

3928

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3929

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3930

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3931

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3932

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3933

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3934

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3935

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3936

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3937

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3938

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3939

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3940

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3941

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3942

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3943

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3944

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

Kiran Kumar Lokere

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

[diff] [blame]

3945

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

Jeff Johnson

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

[diff] [blame]

3946

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3947

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3948

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3949

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Kiran Kumar Lokere

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

[diff] [blame]

3950

smeConfig.csrConfig.nActiveMaxChnTimeBtc = pConfig->nActiveMaxChnTimeBtc;

3951

smeConfig.csrConfig.nActiveMinChnTimeBtc = pConfig->nActiveMinChnTimeBtc;

Kiran Kumar Lokere

458d732

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

[diff] [blame]

3952

smeConfig.csrConfig.disableAggWithBtc = pConfig->disableAggWithBtc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3953

#ifdef WLAN_AP_STA_CONCURRENCY

3954

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3955

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3956

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3957

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3958

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Sudhir Sattayappa Kohalli

eb97d50

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

[diff] [blame]

3959

smeConfig.csrConfig.nNumStaChanCombinedConc = pConfig->nNumStaChanCombinedConc;

3960

smeConfig.csrConfig.nNumP2PChanCombinedConc = pConfig->nNumP2PChanCombinedConc;

3961

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3962

#endif

Jeff Johnson

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

[diff] [blame]

3963

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3964

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3965

3966

#if defined WLAN_FEATURE_VOWIFI

3967

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3968

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3969

#endif

3970

//Remaining config params not obtained from registry

3971

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3972

#ifdef WLAN_FEATURE_11AC

3973

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

3974

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

3975

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Ravi Joshi

83bfaa1

2013-05-28 22:12:08 -0700

[diff] [blame]

3976

smeConfig.csrConfig.enableVhtFor24GHz = pConfig->enableVhtFor24GHzBand;

Jeff Johnson

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

[diff] [blame]

3977

#endif

Shailender Karmuchi

a734f33

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

[diff] [blame]

3978

smeConfig.csrConfig.AdHocChannel5G = pConfig->AdHocChannel5G;

3979

smeConfig.csrConfig.AdHocChannel24 = pConfig->AdHocChannel24G;

Kiran Kumar Lokere

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

[diff] [blame]

3980

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3981

smeConfig.csrConfig.HeartbeatThresh50 = 40;

3982

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3983

if (pConfig->nBandCapability == eCSR_BAND_24)

3984

{

3985

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3986

} else {

3987

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3988

}

Kiran Kumar Lokere

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

[diff] [blame]

3989

smeConfig.csrConfig.cbChoice = 0;

3990

smeConfig.csrConfig.bgScanInterval = 0;

3991

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

Jeff Johnson

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

[diff] [blame]

3992

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3993

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3994

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3995

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

3996

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

Srinivas Girigowda

bbd16eb

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

[diff] [blame]

3997

smeConfig.csrConfig.nRoamIntraBand = pConfig->nRoamIntraBand;

Varun Reddy Yeturu

920df21

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

[diff] [blame]

3998

smeConfig.csrConfig.nProbes = pConfig->nProbes;

Srinivas Girigowda

6cf0b82

2013-06-27 14:00:20 -0700

[diff] [blame]

3999

4000

if (pConfig->nRoamScanHomeAwayTime < (pConfig->nNeighborScanMaxChanTime + (2 * HDD_ROAM_SCAN_CHANNEL_SWITCH_TIME)))

4001

{

4002

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,

4003

"%s: Invalid config, Home away time(%d) is less than twice RF switching time + channel max time(%d)"

4004

" Hence enforcing home away time to disable (0)",

4005

__func__, pConfig->nRoamScanHomeAwayTime,

4006

(pConfig->nNeighborScanMaxChanTime + (2 * HDD_ROAM_SCAN_CHANNEL_SWITCH_TIME)));

4007

pConfig->nRoamScanHomeAwayTime = 0;

4008

}

Varun Reddy Yeturu

920df21

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

[diff] [blame]

4009

smeConfig.csrConfig.nRoamScanHomeAwayTime = pConfig->nRoamScanHomeAwayTime;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

4010

#endif

Jeff Johnson

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

[diff] [blame]

4011

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

4012

Jeff Johnson

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

[diff] [blame]

4013

//FIXME 11d config is hardcoded

Jeff Johnson

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

[diff] [blame]

4014

if ( VOS_STA_SAP_MODE != hdd_get_conparam())

4015

{

4016

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

Jeff Johnson

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

[diff] [blame]

4017

Jeff Johnson

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

[diff] [blame]

4018

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

4019

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

4020

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

4021

* come from NV as per our current implementation */

Jeff Johnson

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

[diff] [blame]

4022

}

Jeff Johnson

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

[diff] [blame]

4023

else

4024

{

4025

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

4026

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

Jeff Johnson

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

[diff] [blame]

4027

Jeff Johnson

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

[diff] [blame]

4028

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

4029

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

4030

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

4031

}

Jeff Johnson

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

[diff] [blame]

4032

hdd_set_power_save_config(pHddCtx, &smeConfig);

4033

hdd_set_btc_config(pHddCtx);

4034

Kiran Kumar Lokere

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

[diff] [blame]

4035

#ifdef WLAN_FEATURE_VOWIFI_11R

Jeff Johnson

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

[diff] [blame]

4036

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

4037

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4038

#ifdef FEATURE_WLAN_LFR

4039

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

4040

if( pConfig->isFastRoamIniFeatureEnabled )

4041

{

4042

pConfig->isFastTransitionEnabled = TRUE;

4043

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

4044

#endif

Jeff Johnson

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

[diff] [blame]

4045

#ifdef FEATURE_WLAN_CCX

4046

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

4047

if( pConfig->isCcxIniFeatureEnabled )

4048

{

4049

pConfig->isFastTransitionEnabled = TRUE;

4050

}

Jeff Johnson

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

[diff] [blame]

4051

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4052

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

4053

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

4054

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

4055

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

4056

#endif

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4057

#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD

4058

smeConfig.csrConfig.isRoamOffloadScanEnabled = pConfig->isRoamOffloadScanEnabled;

Srinivas Girigowda

830bbd0

2013-06-13 19:44:16 -0700

[diff] [blame]

4059

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = pConfig->bFastRoamInConIniFeatureEnabled;

4060

4061

if (0 == smeConfig.csrConfig.isRoamOffloadScanEnabled)

4062

{

4063

/* Disable roaming in concurrency if roam scan offload is disabled */

4064

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = 0;

4065

}

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4066

#endif

Jeff Johnson

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

[diff] [blame]

4067

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

4068

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

4069

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

Kiran Kumar Lokere

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

[diff] [blame]

4070

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

4071

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

Jeff Johnson

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

[diff] [blame]

4072

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

Kiran Kumar Lokere

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

[diff] [blame]

4073

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

Jeff Johnson

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

[diff] [blame]

4074

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

Srinivas Girigowda

de69741

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

[diff] [blame]

4075

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

Kiran Kumar Lokere

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

[diff] [blame]

4076

hdd_string_to_u8_array( pConfig->neighborScanChanList,

4077

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

4078

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

Jeff Johnson

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

[diff] [blame]

4079

WNI_CFG_VALID_CHANNEL_LIST_LEN );

4080

#endif

4081

4082

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

4083

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

4084

Kiran Kumar Lokere

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

[diff] [blame]

4085

//Enable/Disable MCC

Jeff Johnson

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

[diff] [blame]

4086

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

4087

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

4088

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

4089

//Scan Results Aging Time out value

4090

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

4091

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

4092

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

4093

krunal soni

4f087d2

2013-07-29 16:32:26 -0700

[diff] [blame^]

4094

// Prop IE enabling/disabling option

4095

smeConfig.csrConfig.enableOxygenNwk = pConfig->enableOxygenNwk;

4096

Gopichand Nakkala

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

[diff] [blame]

4097

/* update SSR config */

4098

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

Gopichand Nakkala

86e4266

2013-06-11 17:44:11 +0530

[diff] [blame]

4099

/* Update the Directed scan offload setting */

4100

smeConfig.fScanOffload = pHddCtx->cfg_ini->fScanOffload;

Gopichand Nakkala

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

[diff] [blame]

4101

Kiran Kumar Lokere

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

[diff] [blame]

4102

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

Jeff Johnson

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

[diff] [blame]

4103

if ( !HAL_STATUS_SUCCESS( halStatus ) )

4104

{

4105

status = VOS_STATUS_E_FAILURE;

4106

}

4107

Kiran Kumar Lokere

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

[diff] [blame]

4108

4109

return status;

Jeff Johnson

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

[diff] [blame]

}

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

4114

4115

\brief hdd_execute_config_command() -

4116

4117

This function executes an arbitrary configuration set command

4118

4119

\param - pHddCtx - Pointer to the HDD Adapter.

4120

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

4121

4122

4123

\return - 0 for success, non zero for failure

4124

4125

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

4126

4127

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

4128

{

4129

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

4130

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;

4139

unsigned int idx;

4140

unsigned int i;

4141

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

4142

int rv;

Jeff Johnson

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

[diff] [blame]

4143

4144

// assume failure until proven otherwise

4145

vstatus = VOS_STATUS_E_FAILURE;

4146

4147

// clone the command so that we can manipulate it

4148

clone = kstrdup(command, GFP_ATOMIC);

4149

if (NULL == clone)

4150

{

4151

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4152

__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

4157

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

4158

pCmd = clone;

4159

4160

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

4166

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

4171

name = pCmd;

4172

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]

4180

__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

4190

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4191

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

4196

if ('\0' == *value_str)

4197

{

4198

// did not find a value

4199

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4200

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

4205

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

4206

{

4207

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

{

// found a match

break;

}

}

if (tableSize == idx)

4214

{

4215

// did not match the name

4216

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4217

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

4222

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

4223

{

4224

// does not support dynamic configuration

4225

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4226

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

4231

4232

switch (pRegEntry->RegType)

4233

{

4234

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4235

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

4236

if (rv < 0)

4237

goto done;

Jeff Johnson

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

[diff] [blame]

4238

if (value < pRegEntry->VarMin)

4239

{

4240

// out of range

4241

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4242

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4243

goto done;

4244

}

4245

if (value > pRegEntry->VarMax)

4246

{

4247

// out of range

4248

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4249

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4250

goto done;

4251

}

4252

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

4253

break;

4254

4255

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4256

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

4257

if (rv < 0)

4258

goto done;

Jeff Johnson

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

[diff] [blame]

4259

if (value < pRegEntry->VarMin)

4260

{

4261

// out of range

4262

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4263

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4264

goto done;

4265

}

4266

if (value > pRegEntry->VarMax)

4267

{

4268

// out of range

4269

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4270

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4271

goto done;

4272

}

4273

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

4274

break;

4275

4276

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4277

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

4278

if (rv < 0)

4279

goto done;

Jeff Johnson

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

[diff] [blame]

4280

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

4281

{

4282

// out of range

4283

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4284

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

Jeff Johnson

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

[diff] [blame]

4285

goto done;

4286

}

4287

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

4288

{

4289

// out of range

4290

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4291

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

Jeff Johnson

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

[diff] [blame]

4292

goto done;

4293

}

4294

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

4295

break;

4296

4297

case WLAN_PARAM_String:

4298

len_value_str = strlen(value_str);

4299

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

{

// too big

hddLog(LOGE,

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

4304

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4305

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

4306

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

4307

goto done;

4308

}

4309

// copy string plus NUL

4310

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

4311

break;

4312

4313

case WLAN_PARAM_MacAddr:

4314

len_value_str = strlen(value_str);

4315

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

4320

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4321

__func__, value_str,

Jeff Johnson