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

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

[diff] [blame]

2708

#endif

2709

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

2710

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

2711

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

2712

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

2713

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

2714

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

2715

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

2716

2717

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

2718

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

2719

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

2720

#ifdef WLAN_BTAMP_FEATURE

2721

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

2722

#endif //WLAN_BTAMP_FEATURE

2723

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

2724

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

2725

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

2726

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

2727

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

2728

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

2729

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

2730

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

2731

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

2732

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

2733

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

2734

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

2735

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]

2736

#ifdef WLAN_FEATURE_11AC

2737

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

2738

#endif

2739

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

2740

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

2741

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]

2742

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]

2743

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]

2744

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]

2745

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]

2746

Leo Chang

64d68bc

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

[diff] [blame]

2747

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

2748

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]

2752

Jeff Johnson

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

[diff] [blame]

2753

#define CFG_VALUE_MAX_LEN 256

2754

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2755

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

2756

{

2757

unsigned int idx;

2758

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2759

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

2760

v_U32_t value;

2761

char valueStr[CFG_VALUE_MAX_LEN];

2762

char configStr[CFG_ENTRY_MAX_LEN];

2763

char *fmt;

2764

void *pField;

2765

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2770

*pCur = '\0';

2771

Kiran Kumar Lokere

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

[diff] [blame]

2772

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

Jeff Johnson

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

[diff] [blame]

2773

{

2774

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

2775

2776

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

2777

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

Kiran Kumar Lokere

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

[diff] [blame]

2778

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

Jeff Johnson

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

[diff] [blame]

2779

{

2780

value = 0;

2781

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

2782

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

2795

}

2796

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2797

{

2798

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

2799

}

2800

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2801

{

2802

pMacAddr = (v_MACADDR_t *) pField;

2803

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2804

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

2815

}

2816

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2821

"*" : "");

2822

2823

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

2824

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

2825

#ifdef RETURN_IN_BUFFER

2826

if (curlen <= buflen)

2827

{

2828

// copy string + '\0'

2829

memcpy(pCur, configStr, curlen+1);

2830

2831

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2838

return VOS_STATUS_E_RESOURCES;

2839

}

2840

#else

2841

printk(KERN_CRIT "%s", configStr);

2842

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2847

// notify application that output is in system log

2848

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

2849

#endif // RETURN_IN_BUFFER

2850

2851

return VOS_STATUS_SUCCESS;

2852

}

2853

2854

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

Kiran Kumar Lokere

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

[diff] [blame]

2855

char *name, char** value)

Jeff Johnson

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

[diff] [blame]

2856

{

2857

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2858

unsigned long i;

2859

2860

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

2861

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

2862

*value = iniTable[i].value;

2863

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

2864

WLAN_INI_FILE, name, *value);

2865

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2873

{

2874

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

2875

return c-'0';

2876

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

2877

return c-'a'+10;

2878

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)

2886

{

2887

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2888

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2889

unsigned int idx;

2890

void *pField;

2891

char *value_str = NULL;

2892

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2897

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2898

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

2899

v_U32_t cbOutString;

2900

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2901

int rv;

Jeff Johnson

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

[diff] [blame]

2902

2903

// sanity test

2904

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2905

{

2906

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]

2907

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2908

}

2909

2910

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

2911

{

2912

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

2913

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

2914

2915

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

2916

2917

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

2918

{

2919

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

2920

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2921

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2922

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2927

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2928

{

2929

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

2930

// If not, use the default value.

2931

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2932

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

2933

if (rv < 0) {

2934

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

2935

__func__, pRegEntry->RegName);

2936

value = pRegEntry->VarDefault;

2937

}

Jeff Johnson

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

[diff] [blame]

2938

}

2939

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2940

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

2941

if (rv < 0) {

2942

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

2943

__func__, pRegEntry->RegName);

2944

value = pRegEntry->VarDefault;

2945

}

Jeff Johnson

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

[diff] [blame]

2946

}

2947

else {

2948

value = pRegEntry->VarDefault;

2949

}

2950

2951

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

2952

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2953

{

2954

if ( value > pRegEntry->VarMax )

2955

{

2956

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2957

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

Jeff Johnson

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

[diff] [blame]

2958

value = pRegEntry->VarMax;

2959

}

2960

2961

if ( value < pRegEntry->VarMin )

2962

{

2963

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2964

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

Jeff Johnson

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

[diff] [blame]

2965

value = pRegEntry->VarMin;

2966

}

2967

}

2968

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

2969

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2970

{

2971

if ( value > pRegEntry->VarMax )

2972

{

2973

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]

2974

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

Jeff Johnson

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

[diff] [blame]

2975

value = pRegEntry->VarDefault;

2976

}

2977

2978

if ( value < pRegEntry->VarMin )

2979

{

2980

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]

2981

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

Jeff Johnson

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

[diff] [blame]

2982

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2987

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

2988

}

2989

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2990

{

2991

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

2992

// If not, use the default value.

2993

if (VOS_STATUS_SUCCESS == match_status)

2994

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2995

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

2996

if (rv < 0) {

2997

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

2998

__func__, pRegEntry->RegName);

2999

svalue = (v_S31_t)pRegEntry->VarDefault;

3000

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

3005

}

3006

3007

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

3008

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

3009

{

3010

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

3011

{

3012

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3013

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

Jeff Johnson

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

[diff] [blame]

3014

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

3015

svalue = (v_S31_t)pRegEntry->VarMax;

3016

}

3017

3018

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

3019

{

3020

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3021

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

Jeff Johnson

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

[diff] [blame]

3022

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

3023

svalue = (v_S31_t)pRegEntry->VarMin;

3024

}

3025

}

3026

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

3027

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

3028

{

3029

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

3030

{

3031

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

3032

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3033

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3034

(int)pRegEntry->VarMax,

3035

(int)pRegEntry->VarDefault );

3036

svalue = (v_S31_t)pRegEntry->VarDefault;

3037

}

3038

3039

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

3040

{

3041

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

3042

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3043

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3044

(int)pRegEntry->VarMin,

3045

(int)pRegEntry->VarDefault);

3046

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3051

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

3052

}

3053

// Handle string parameters

3054

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3055

{

3056

#ifdef WLAN_CFG_DEBUG

3057

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]

3058

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

Jeff Johnson

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

[diff] [blame]

3059

#endif

3060

Kiran Kumar Lokere

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

[diff] [blame]

3061

if ( match_status == VOS_STATUS_SUCCESS)

Jeff Johnson

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

[diff] [blame]

3062

{

3063

len_value_str = strlen(value_str);

3064

3065

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

Kiran Kumar Lokere

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

[diff] [blame]

3066

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]

3067

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

Jeff Johnson

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

[diff] [blame]

3068

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

3069

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

3070

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

}

else

{

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

3075

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

3076

}

3077

}

Kiran Kumar Lokere

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

[diff] [blame]

3078

else

Jeff Johnson

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

[diff] [blame]

3079

{

3080

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

3081

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

3082

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

Kiran Kumar Lokere

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

[diff] [blame]

3083

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

Jeff Johnson

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

[diff] [blame]

3084

}

3085

}

3086

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3087

{

3088

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

Kiran Kumar Lokere

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

[diff] [blame]

3089

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

3090

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

Jeff Johnson

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

[diff] [blame]

3091

continue;

3092

}

3093

candidate = (char*)pRegEntry->VarDefault;

3094

if ( match_status == VOS_STATUS_SUCCESS) {

3095

len_value_str = strlen(value_str);

3096

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

Kiran Kumar Lokere

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

[diff] [blame]

3097

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]

3098

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

Jeff Johnson

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

[diff] [blame]

3099

}

3100

else

3101

candidate = value_str;

3102

}

3103

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

3104

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

3105

{

Kiran Kumar Lokere

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

[diff] [blame]

3106

((char*)pField)[i] =

3107

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

3112

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]

3113

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3114

}

3115

3116

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

3117

if( (match_status == VOS_STATUS_SUCCESS) &&

3118

(idx < MAX_CFG_INI_ITEMS) )

3119

{

3120

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

}

}

print_hdd_cfg(pHddCtx);

3125

3126

return( ret_status );

3127

}

3128

3129

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

3130

{

Kiran Kumar Lokere

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

[diff] [blame]

3131

switch (dot11Mode)

Jeff Johnson

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

[diff] [blame]

3132

{

3133

case (eHDD_DOT11_MODE_abg):

3134

return eCSR_DOT11_MODE_abg;

3135

case (eHDD_DOT11_MODE_11b):

3136

return eCSR_DOT11_MODE_11b;

3137

case (eHDD_DOT11_MODE_11g):

3138

return eCSR_DOT11_MODE_11g;

3139

default:

3140

case (eHDD_DOT11_MODE_11n):

3141

return eCSR_DOT11_MODE_11n;

3142

case (eHDD_DOT11_MODE_11g_ONLY):

3143

return eCSR_DOT11_MODE_11g_ONLY;

3144

case (eHDD_DOT11_MODE_11n_ONLY):

3145

return eCSR_DOT11_MODE_11n_ONLY;

3146

case (eHDD_DOT11_MODE_11b_ONLY):

3147

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

3148

#ifdef WLAN_FEATURE_11AC

3149

case (eHDD_DOT11_MODE_11ac_ONLY):

3150

return eCSR_DOT11_MODE_11ac_ONLY;

3151

case (eHDD_DOT11_MODE_11ac):

3152

return eCSR_DOT11_MODE_11ac;

3153

#endif

Jeff Johnson

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

[diff] [blame]

3154

case (eHDD_DOT11_MODE_AUTO):

3155

return eCSR_DOT11_MODE_AUTO;

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3160

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

Jeff Johnson

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

[diff] [blame]

3161

{

3162

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3163

tSmeBtcConfig btcParams;

Kiran Kumar Lokere

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

[diff] [blame]

3164

Jeff Johnson

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

[diff] [blame]

3165

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

3166

3167

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

3168

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

3169

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

3170

Jeff Johnson

32d95a3

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

[diff] [blame]

3171

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

3172

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

3173

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

3174

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

3175

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

3176

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

3177

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

3178

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

3179

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

3180

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

3181

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

3182

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

3183

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

3184

Jeff Johnson

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

[diff] [blame]

3185

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

3186

}

3187

Kiran Kumar Lokere

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

[diff] [blame]

3188

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

Jeff Johnson

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

[diff] [blame]

3189

{

3190

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3191

3192

tPmcBmpsConfigParams bmpsParams;

Kiran Kumar Lokere

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

[diff] [blame]

3193

Jeff Johnson

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

[diff] [blame]

3194

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

Kiran Kumar Lokere

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

[diff] [blame]

3195

Jeff Johnson

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

[diff] [blame]

3196

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

3197

{

3198

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

3199

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

3200

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3201

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3202

}

3203

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

3204

{

3205

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

3206

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

3207

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3208

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3209

}

3210

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

3211

{

3212

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

3213

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

3214

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3215

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3216

}

3217

3218

if (pConfig->fIsImpsEnabled)

3219

{

3220

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

3225

}

3226

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

3227

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

3228

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

3229

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

3230

Jeff Johnson

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

[diff] [blame]

3231

if (pConfig->fIsBmpsEnabled)

3232

{

3233

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

3238

}

3239

3240

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

3241

3242

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

3243

{

3244

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

3245

}

Kiran Kumar Lokere

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

[diff] [blame]

3246

Jeff Johnson

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

[diff] [blame]

3247

if(pConfig->fIsAutoBmpsTimerEnabled)

3248

{

3249

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3255

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 )

3260

{

3261

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

3265

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

3266

{

3267

int val;

3268

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

3269

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

3270

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

3271

{

3272

intArray[*len] = (tANI_U8) val;

3273

*len += 1;

3274

}

3275

s = strpbrk( s, "," );

3276

if( s )

3277

s++;

3278

}

Jeff Johnson

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

[diff] [blame]

3279

3280

return VOS_STATUS_SUCCESS;

Kiran Kumar Lokere

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

[diff] [blame]

3281

Jeff Johnson

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

[diff] [blame]

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

3287

{

3288

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

3289

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3290

tANI_U32 val;

3291

#endif

Jeff Johnson

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

[diff] [blame]

3292

3293

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

3294

tSirMacHTCapabilityInfo htCapInfo;

3295

Jeff Johnson

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

[diff] [blame]

3296

Kiran Kumar Lokere

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

[diff] [blame]

3297

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

Jeff Johnson

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

[diff] [blame]

3298

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

3299

{

3300

fStatus = FALSE;

3301

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

3302

}

Kiran Kumar Lokere

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

[diff] [blame]

3303

3304

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

Jeff Johnson

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

[diff] [blame]

3305

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3306

{

3307

fStatus = FALSE;

3308

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

3309

}

3310

3311

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

3312

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3313

{

3314

fStatus = FALSE;

3315

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

3316

}

3317

3318

if ( 0 != pConfig->Cfg1Id )

3319

{

Kiran Kumar Lokere

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

[diff] [blame]

3320

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

Jeff Johnson

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

[diff] [blame]

3321

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3322

{

3323

fStatus = FALSE;

3324

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

3325

}

Kiran Kumar Lokere

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

[diff] [blame]

3326

Jeff Johnson

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

[diff] [blame]

3327

}

3328

3329

if ( 0 != pConfig->Cfg2Id )

3330

{

Kiran Kumar Lokere

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

[diff] [blame]

3331

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

Jeff Johnson

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

[diff] [blame]

3332

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3333

{

3334

fStatus = FALSE;

3335

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

}

}

if ( 0 != pConfig->Cfg3Id )

3340

{

Kiran Kumar Lokere

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

[diff] [blame]

3341

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

Jeff Johnson

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

[diff] [blame]

3342

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3343

{

3344

fStatus = FALSE;

3345

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

}

}

if ( 0 != pConfig->Cfg4Id )

3350

{

Kiran Kumar Lokere

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

[diff] [blame]

3351

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

Jeff Johnson

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

[diff] [blame]

3352

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3353

{

3354

fStatus = FALSE;

3355

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

}

}

if ( 0 != pConfig->Cfg5Id )

3360

{

Kiran Kumar Lokere

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

[diff] [blame]

3361

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

Jeff Johnson

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

[diff] [blame]

3362

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3363

{

3364

fStatus = FALSE;

3365

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

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3369

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

Jeff Johnson

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

[diff] [blame]

3370

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3371

{

3372

fStatus = FALSE;

3373

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

3374

}

Kiran Kumar Lokere

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

[diff] [blame]

3375

3376

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

Jeff Johnson

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

[diff] [blame]

3377

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3378

{

3379

fStatus = FALSE;

3380

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

3381

}

3382

Kiran Kumar Lokere

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

[diff] [blame]

3383

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

Jeff Johnson

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

[diff] [blame]

3384

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

3385

{

3386

fStatus = FALSE;

3387

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

3388

}

3389

3390

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

3391

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3392

{

3393

fStatus = FALSE;

3394

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

3395

}

3396

Kiran Kumar Lokere

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

[diff] [blame]

3397

if (pConfig->fIsAutoIbssBssid)

Jeff Johnson

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

[diff] [blame]

3398

{

Kiran Kumar Lokere

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

[diff] [blame]

3399

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

Jeff Johnson

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

[diff] [blame]

3400

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

3401

{

3402

fStatus = FALSE;

3403

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

3404

}

3405

}

3406

else

Kiran Kumar Lokere

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

[diff] [blame]

3407

{

Jeff Johnson

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

[diff] [blame]

3408

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

3409

{

3410

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3411

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

3412

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

Jeff Johnson

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

[diff] [blame]

3413

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

Kiran Kumar Lokere

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

[diff] [blame]

3414

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

Jeff Johnson

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

[diff] [blame]

3415

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

3416

{

3417

fStatus = FALSE;

3418

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]

3428

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

Jeff Johnson

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

[diff] [blame]

3429

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3430

{

3431

fStatus = FALSE;

3432

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

3433

}

3434

Kiran Kumar Lokere

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

[diff] [blame]

3435

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

Jeff Johnson

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

[diff] [blame]

3436

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3437

{

3438

fStatus = FALSE;

3439

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

3440

}

3441

3442

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

3443

{

3444

fStatus = FALSE;

3445

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

3446

}

3447

Kiran Kumar Lokere

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

[diff] [blame]

3448

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

Jeff Johnson

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

[diff] [blame]

3449

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3450

{

3451

fStatus = FALSE;

3452

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

3453

}

Kiran Kumar Lokere

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

[diff] [blame]

3454

Jeff Johnson

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

[diff] [blame]

3455

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

3456

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3457

{

3458

fStatus = FALSE;

3459

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

3460

}

3461

Jeff Johnson

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

[diff] [blame]

3462

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

3463

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3464

{

3465

fStatus = FALSE;

3466

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

3467

}

3468

Kiran Kumar Lokere

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

[diff] [blame]

3469

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

Jeff Johnson

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

[diff] [blame]

3470

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3471

{

3472

fStatus = FALSE;

3473

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

3474

}

3475

Kiran Kumar Lokere

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

[diff] [blame]

3476

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

Jeff Johnson

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

[diff] [blame]

3477

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3478

{

3479

fStatus = FALSE;

3480

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

3481

}

3482

Gopichand Nakkala

98a98af

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

[diff] [blame]

3483

#ifdef FEATURE_WLAN_LFR

3484

if (pConfig->isFastRoamIniFeatureEnabled)

3485

{

3486

pConfig->fEnableFwRssiMonitoring = TRUE;

3487

}

3488

#endif

3489

#ifdef FEATURE_WLAN_CCX

3490

if (pConfig->isCcxIniFeatureEnabled)

3491

{

3492

pConfig->fEnableFwRssiMonitoring = TRUE;

3493

}

3494

#endif

Kiran Kumar Lokere

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

[diff] [blame]

3495

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

Jeff Johnson

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

[diff] [blame]

3496

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3497

{

3498

fStatus = FALSE;

3499

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

3500

}

3501

Kiran Kumar Lokere

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

[diff] [blame]

3502

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

Jeff Johnson

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

[diff] [blame]

3503

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3504

{

3505

fStatus = FALSE;

3506

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

3507

}

3508

Kiran Kumar Lokere

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

[diff] [blame]

3509

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

Jeff Johnson

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

[diff] [blame]

3510

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3511

{

3512

fStatus = FALSE;

3513

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

3514

}

3515

Kiran Kumar Lokere

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

[diff] [blame]

3516

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

Jeff Johnson

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

[diff] [blame]

3517

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3518

{

3519

fStatus = FALSE;

3520

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

3521

}

3522

Kiran Kumar Lokere

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

[diff] [blame]

3523

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

Jeff Johnson

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

[diff] [blame]

3524

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3525

{

3526

fStatus = FALSE;

3527

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

3528

}

3529

Kiran Kumar Lokere

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

[diff] [blame]

3530

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

Jeff Johnson

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

[diff] [blame]

3531

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3532

{

3533

fStatus = FALSE;

3534

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]

3535

}

Jeff Johnson

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

[diff] [blame]

3536

Kiran Kumar Lokere

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

[diff] [blame]

3537

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

Jeff Johnson

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

[diff] [blame]

3538

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3539

{

3540

fStatus = FALSE;

3541

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

3542

}

Kiran Kumar Lokere

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

[diff] [blame]

3543

Sejal Chauhan

bcde8bc

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

[diff] [blame]

3544

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

3545

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3546

{

3547

fStatus = FALSE;

3548

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

3549

}

3550

Jeff Johnson

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

[diff] [blame]

3551

#if defined WLAN_FEATURE_VOWIFI

Kiran Kumar Lokere

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

[diff] [blame]

3552

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

Jeff Johnson

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

[diff] [blame]

3553

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3554

{

3555

fStatus = FALSE;

3556

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

3557

}

3558

Kiran Kumar Lokere

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

[diff] [blame]

3559

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

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_RRM_OPERATING_CHAN_MAX 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_RRM_NON_OPERATING_CHAN_MAX, pConfig->nOutChanMeasMaxDuration,

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

3571

}

3572

Kiran Kumar Lokere

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

[diff] [blame]

3573

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

Jeff Johnson

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

[diff] [blame]

3574

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3575

#endif

3576

Kiran Kumar Lokere

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

[diff] [blame]

3577

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

Jeff Johnson

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

[diff] [blame]

3578

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3579

{

3580

fStatus = FALSE;

3581

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

3582

}

3583

Kiran Kumar Lokere

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

[diff] [blame]

3584

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

Jeff Johnson

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

[diff] [blame]

3585

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3586

{

3587

fStatus = FALSE;

3588

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

3589

}

3590

Kiran Kumar Lokere

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

[diff] [blame]

3591

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

Jeff Johnson

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

[diff] [blame]

3592

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3593

{

3594

fStatus = FALSE;

3595

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

3596

}

3597

Kiran Kumar Lokere

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

[diff] [blame]

3598

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

Jeff Johnson

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

[diff] [blame]

3599

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3600

{

3601

fStatus = FALSE;

3602

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

3603

}

3604

Kiran Kumar Lokere

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

[diff] [blame]

3605

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]

3606

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3607

{

3608

fStatus = FALSE;

3609

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

3610

}

3611

Kiran Kumar Lokere

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

[diff] [blame]

3612

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]

3613

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3614

{

3615

fStatus = FALSE;

3616

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

3617

}

3618

3619

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

3620

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3621

{

3622

fStatus = FALSE;

3623

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

3624

}

3625

Kiran Kumar Lokere

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

[diff] [blame]

3626

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

Jeff Johnson

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

[diff] [blame]

3627

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3628

{

3629

fStatus = FALSE;

3630

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

3631

}

Kiran Kumar Lokere

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

[diff] [blame]

3632

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

Jeff Johnson

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

[diff] [blame]

3633

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3634

{

3635

fStatus = FALSE;

3636

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

3637

}

3638

3639

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

3640

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3641

{

3642

fStatus = FALSE;

3643

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]

3644

}

Jeff Johnson

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

[diff] [blame]

3645

Jeff Johnson

eed2dca

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

[diff] [blame]

3646

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

Jeff Johnson

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

[diff] [blame]

3647

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

Jeff Johnson

eed2dca

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

[diff] [blame]

3648

{

3649

fStatus = FALSE;

3650

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

3651

}

Kiran Kumar Lokere

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

[diff] [blame]

3652

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

Jeff Johnson

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

[diff] [blame]

3653

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3654

{

3655

fStatus = FALSE;

3656

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

3657

}

Kiran Kumar Lokere

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

[diff] [blame]

3658

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

Jeff Johnson

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

[diff] [blame]

3659

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3660

{

3661

fStatus = FALSE;

3662

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

3663

}

3664

Kiran Kumar Lokere

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

[diff] [blame]

3665

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

Jeff Johnson

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

[diff] [blame]

3666

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3667

{

3668

fStatus = FALSE;

3669

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

3670

}

Kiran Kumar Lokere

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

[diff] [blame]

3671

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

Jeff Johnson

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

[diff] [blame]

3672

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3673

{

3674

fStatus = FALSE;

3675

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

3676

}

3677

Jeff Johnson

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

[diff] [blame]

3678

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

3679

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3680

{

3681

fStatus = FALSE;

3682

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

3683

}

3684

Kiran Kumar Lokere

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

[diff] [blame]

3685

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

Jeff Johnson

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

[diff] [blame]

3686

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3687

==eHAL_STATUS_FAILURE)

3688

{

3689

fStatus = FALSE;

3690

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

3691

}

3692

Kiran Kumar Lokere

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

[diff] [blame]

3693

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

Jeff Johnson

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

[diff] [blame]

3694

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3695

==eHAL_STATUS_FAILURE)

3696

{

3697

fStatus = FALSE;

3698

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

3699

}

3700

Kiran Kumar Lokere

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

[diff] [blame]

3701

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

Jeff Johnson

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

[diff] [blame]

3702

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

3703

{

3704

fStatus = FALSE;

3705

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

3706

}

3707

Jeff Johnson

d13512a

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

[diff] [blame]

3708

Kiran Kumar Lokere

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

[diff] [blame]

3709

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

Jeff Johnson

d13512a

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

[diff] [blame]

3710

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3711

{

3712

fStatus = FALSE;

3713

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

3714

}

3715

Jeff Johnson

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

[diff] [blame]

3716

#ifdef WLAN_FEATURE_11AC

3717

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

3718

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

3719

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

3720

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

3721

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3722

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

3728

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

Jeff Johnson

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

[diff] [blame]

3729

Kiran Kumar Lokere

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

[diff] [blame]

3730

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

Jeff Johnson

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

[diff] [blame]

3731

temp, NULL, eANI_BOOLEAN_FALSE)

3732

==eHAL_STATUS_FAILURE)

3733

{

3734

fStatus = FALSE;

3735

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

3736

}

3737

3738

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

Kiran Kumar Lokere

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

[diff] [blame]

3739

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

Jeff Johnson

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

[diff] [blame]

3740

Kiran Kumar Lokere

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

[diff] [blame]

3741

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

3742

temp, NULL, eANI_BOOLEAN_FALSE)

3743

==eHAL_STATUS_FAILURE)

3744

{

3745

fStatus = FALSE;

3746

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

3747

}

3748

3749

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

Kiran Kumar Lokere

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

[diff] [blame]

3750

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

Jeff Johnson

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

[diff] [blame]

3751

Kiran Kumar Lokere

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

[diff] [blame]

3752

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

3753

temp, NULL, eANI_BOOLEAN_FALSE)

3754

==eHAL_STATUS_FAILURE)

3755

{

3756

fStatus = FALSE;

3757

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]

3763

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

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

3764

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3765

{

3766

fStatus = FALSE;

3767

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

3768

}

3769

Kiran Kumar Lokere

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

[diff] [blame]

3770

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

Pratik Bhalgat

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

[diff] [blame]

3771

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3772

==eHAL_STATUS_FAILURE)

3773

{

3774

fStatus = FALSE;

3775

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

3776

}

3777

3778

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

3779

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3780

Kiran Kumar Lokere

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

[diff] [blame]

3781

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

Pratik Bhalgat

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

[diff] [blame]

3782

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

3783

==eHAL_STATUS_FAILURE)

3784

{

3785

fStatus = FALSE;

3786

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

3787

}

3788

Kiran Kumar Lokere

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

[diff] [blame]

3789

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

Pratik Bhalgat

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

[diff] [blame]

3790

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3791

==eHAL_STATUS_FAILURE)

3792

{

3793

fStatus = FALSE;

3794

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

3795

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3796

3797

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3798

if(pConfig->fEnableVSTASupport)

3799

{

3800

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

3801

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3802

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3807

}

Kiran Kumar Lokere

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

[diff] [blame]

3808

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

Gopichand Nakkala

976e325

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

[diff] [blame]

3809

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3810

{

3811

fStatus = FALSE;

3812

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

3813

}

3814

#endif

Kiran Kumar Lokere

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

[diff] [blame]

3815

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3816

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3817

==eHAL_STATUS_FAILURE)

3818

{

3819

fStatus = FALSE;

3820

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

3821

}

Pratik Bhalgat

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

[diff] [blame]

3822

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3823

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

3824

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3825

{

3826

fStatus = FALSE;

3827

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

3828

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

3829

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

3830

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3831

{

3832

fStatus = FALSE;

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

3833

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]

3834

}

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

3835

3836

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

3837

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3838

{

3839

fStatus = FALSE;

3840

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

3841

}

3842

3843

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

3844

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3845

{

3846

fStatus = FALSE;

3847

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

3848

}

3849

3850

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

3851

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3852

{

3853

fStatus = FALSE;

3854

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

3855

}

3856

Gopichand Nakkala

42bc89e

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

[diff] [blame]

3857

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

3858

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3859

{

3860

fStatus = FALSE;

3861

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

3862

}

3863

Gopichand Nakkala

79ff85d

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

[diff] [blame]

3864

#ifdef FEATURE_WLAN_TDLS

3865

3866

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK, pConfig->fTDLSUapsdMask,

3867

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3868

{

3869

fStatus = FALSE;

3870

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

3871

}

3872

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_BUF_STA_ENABLED, pConfig->fEnableTDLSBufferSta,

3873

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3874

{

3875

fStatus = FALSE;

3876

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

3877

}

3878

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_PUAPSD_INACT_TIME, pConfig->fTDLSPuapsdInactivityTimer,

3879

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3880

{

3881

fStatus = FALSE;

3882

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

3883

}

3884

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TDLS_RX_FRAME_THRESHOLD, pConfig->fTDLSRxFrameThreshold,

3885

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3886

{

3887

fStatus = FALSE;

3888

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

}

#endif

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3897

Kiran Kumar Lokere

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

[diff] [blame]

3898

\brief hdd_init_set_sme_config() -

Jeff Johnson

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

[diff] [blame]

3899

3900

This function initializes the sme configuration parameters

Kiran Kumar Lokere

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

[diff] [blame]

3901

Jeff Johnson

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

[diff] [blame]

3902

\param - pHddCtx - Pointer to the HDD Adapter.

Kiran Kumar Lokere

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

[diff] [blame]

3903

Jeff Johnson

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

[diff] [blame]

3904

\return - 0 for success, non zero for failure

Kiran Kumar Lokere

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

[diff] [blame]

3905

Jeff Johnson

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

[diff] [blame]

3906

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

3907

3908

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3909

{

3910

VOS_STATUS status = VOS_STATUS_SUCCESS;

3911

eHalStatus halStatus;

3912

tSmeConfigParams smeConfig;

3913

3914

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3915

3916

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3917

Kiran Kumar Lokere

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

[diff] [blame]

3918

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

Jeff Johnson

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

[diff] [blame]

3919

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

3920

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

3921

3922

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3923

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3924

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

Jeff Johnson

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

[diff] [blame]

3925

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3926

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3927

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3928

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3929

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3930

3931

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

3932

3933

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3934

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3935

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3936

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3937

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3938

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3939

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3940

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3941

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3942

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3943

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3944

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3945

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3946

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3947

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3948

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3949

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

Kiran Kumar Lokere

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

[diff] [blame]

3950

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

Jeff Johnson

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

[diff] [blame]

3951

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3952

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3953

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3954

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Kiran Kumar Lokere

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

[diff] [blame]

3955

smeConfig.csrConfig.nActiveMaxChnTimeBtc = pConfig->nActiveMaxChnTimeBtc;

3956

smeConfig.csrConfig.nActiveMinChnTimeBtc = pConfig->nActiveMinChnTimeBtc;

Kiran Kumar Lokere

458d732

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

[diff] [blame]

3957

smeConfig.csrConfig.disableAggWithBtc = pConfig->disableAggWithBtc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3958

#ifdef WLAN_AP_STA_CONCURRENCY

3959

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3960

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3961

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3962

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3963

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Sudhir Sattayappa Kohalli

eb97d50

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

[diff] [blame]

3964

smeConfig.csrConfig.nNumStaChanCombinedConc = pConfig->nNumStaChanCombinedConc;

3965

smeConfig.csrConfig.nNumP2PChanCombinedConc = pConfig->nNumP2PChanCombinedConc;

3966

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3967

#endif

Jeff Johnson

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

[diff] [blame]

3968

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3969

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3970

3971

#if defined WLAN_FEATURE_VOWIFI

3972

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3973

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3974

#endif

3975

//Remaining config params not obtained from registry

3976

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3977

#ifdef WLAN_FEATURE_11AC

3978

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

3979

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

3980

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Ravi Joshi

83bfaa1

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

[diff] [blame]

3981

smeConfig.csrConfig.enableVhtFor24GHz = pConfig->enableVhtFor24GHzBand;

Jeff Johnson

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

[diff] [blame]

3982

#endif

Shailender Karmuchi

a734f33

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

[diff] [blame]

3983

smeConfig.csrConfig.AdHocChannel5G = pConfig->AdHocChannel5G;

3984

smeConfig.csrConfig.AdHocChannel24 = pConfig->AdHocChannel24G;

Kiran Kumar Lokere

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

[diff] [blame]

3985

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3986

smeConfig.csrConfig.HeartbeatThresh50 = 40;

3987

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3988

if (pConfig->nBandCapability == eCSR_BAND_24)

3989

{

3990

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3991

} else {

3992

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3993

}

Kiran Kumar Lokere

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

[diff] [blame]

3994

smeConfig.csrConfig.cbChoice = 0;

3995

smeConfig.csrConfig.bgScanInterval = 0;

3996

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

Jeff Johnson

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

[diff] [blame]

3997

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3998

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3999

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

4000

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

4001

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

Srinivas Girigowda

bbd16eb

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

[diff] [blame]

4002

smeConfig.csrConfig.nRoamIntraBand = pConfig->nRoamIntraBand;

Varun Reddy Yeturu

920df21

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

[diff] [blame]

4003

smeConfig.csrConfig.nProbes = pConfig->nProbes;

Srinivas Girigowda

6cf0b82

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

[diff] [blame]

4004

4005

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

4006

{

4007

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,

4008

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

4009

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

4010

__func__, pConfig->nRoamScanHomeAwayTime,

4011

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

4012

pConfig->nRoamScanHomeAwayTime = 0;

4013

}

Varun Reddy Yeturu

920df21

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

[diff] [blame]

4014

smeConfig.csrConfig.nRoamScanHomeAwayTime = pConfig->nRoamScanHomeAwayTime;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

4015

#endif

Jeff Johnson

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

[diff] [blame]

4016

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

4017

Jeff Johnson

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

[diff] [blame]

4018

//FIXME 11d config is hardcoded

Jeff Johnson

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

[diff] [blame]

4019

if ( VOS_STA_SAP_MODE != hdd_get_conparam())

4020

{

4021

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

Jeff Johnson

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

[diff] [blame]

4022

Jeff Johnson

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

[diff] [blame]

4023

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

4024

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

4025

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

4026

* come from NV as per our current implementation */

Jeff Johnson

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

[diff] [blame]

4027

}

Jeff Johnson

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

[diff] [blame]

4028

else

4029

{

4030

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

4031

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

Jeff Johnson

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

[diff] [blame]

4032

Jeff Johnson

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

[diff] [blame]

4033

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

4034

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

4035

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

4036

}

Jeff Johnson

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

[diff] [blame]

4037

hdd_set_power_save_config(pHddCtx, &smeConfig);

4038

hdd_set_btc_config(pHddCtx);

4039

Kiran Kumar Lokere

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

[diff] [blame]

4040

#ifdef WLAN_FEATURE_VOWIFI_11R

Jeff Johnson

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

[diff] [blame]

4041

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

4042

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4043

#ifdef FEATURE_WLAN_LFR

4044

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

4045

if( pConfig->isFastRoamIniFeatureEnabled )

4046

{

4047

pConfig->isFastTransitionEnabled = TRUE;

4048

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

4049

#endif

Jeff Johnson

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

[diff] [blame]

4050

#ifdef FEATURE_WLAN_CCX

4051

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

4052

if( pConfig->isCcxIniFeatureEnabled )

4053

{

4054

pConfig->isFastTransitionEnabled = TRUE;

4055

}

Jeff Johnson

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

[diff] [blame]

4056

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4057

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

4058

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

4059

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

4060

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

4061

#endif

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4062

#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD

4063

smeConfig.csrConfig.isRoamOffloadScanEnabled = pConfig->isRoamOffloadScanEnabled;

Srinivas Girigowda

830bbd0

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

[diff] [blame]

4064

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = pConfig->bFastRoamInConIniFeatureEnabled;

4065

4066

if (0 == smeConfig.csrConfig.isRoamOffloadScanEnabled)

4067

{

4068

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

4069

smeConfig.csrConfig.bFastRoamInConIniFeatureEnabled = 0;

4070

}

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4071

#endif

Jeff Johnson

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

[diff] [blame]

4072

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

4073

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

4074

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

Kiran Kumar Lokere

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

[diff] [blame]

4075

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

4076

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

Jeff Johnson

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

[diff] [blame]

4077

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

Kiran Kumar Lokere

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

[diff] [blame]

4078

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

Jeff Johnson

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

[diff] [blame]

4079

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

Srinivas Girigowda

de69741

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

[diff] [blame]

4080

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

Kiran Kumar Lokere

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

[diff] [blame]

4081

hdd_string_to_u8_array( pConfig->neighborScanChanList,

4082

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

4083

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

Jeff Johnson

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

[diff] [blame]

4084

WNI_CFG_VALID_CHANNEL_LIST_LEN );

4085

#endif

4086

4087

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

4088

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

4089

Kiran Kumar Lokere

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

[diff] [blame]

4090

//Enable/Disable MCC

Jeff Johnson

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

[diff] [blame]

4091

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

4092

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

4093

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

4094

//Scan Results Aging Time out value

4095

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

4096

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

4097

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

4098

Gopichand Nakkala

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

[diff] [blame]

4099

/* update SSR config */

4100

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

Gopichand Nakkala

86e4266

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

[diff] [blame]

4101

/* Update the Directed scan offload setting */

4102

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

Gopichand Nakkala

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

[diff] [blame]

4103

Kiran Kumar Lokere

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

[diff] [blame]

4104

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

Jeff Johnson

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

[diff] [blame]

4105

if ( !HAL_STATUS_SUCCESS( halStatus ) )

4106

{

4107

status = VOS_STATUS_E_FAILURE;

4108

}

4109

Kiran Kumar Lokere

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

[diff] [blame]

4110

4111

return status;

Jeff Johnson

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

[diff] [blame]

}

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

4116

4117

\brief hdd_execute_config_command() -

4118

4119

This function executes an arbitrary configuration set command

4120

4121

\param - pHddCtx - Pointer to the HDD Adapter.

4122

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

4123

4124

4125

\return - 0 for success, non zero for failure

4126

4127

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

4128

4129

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

4130

{

4131

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

4132

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;

4141

unsigned int idx;

4142

unsigned int i;

4143

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

4144

int rv;

Jeff Johnson

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

[diff] [blame]

4145

4146

// assume failure until proven otherwise

4147

vstatus = VOS_STATUS_E_FAILURE;

4148

4149

// clone the command so that we can manipulate it

4150

clone = kstrdup(command, GFP_ATOMIC);

4151

if (NULL == clone)

4152

{

4153

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4154

__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

4159

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

4160

pCmd = clone;

4161

4162

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

4168

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

4173

name = pCmd;

4174

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]

4182

__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

4192

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4193

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

4198

if ('\0' == *value_str)

4199

{

4200

// did not find a value

4201

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4202

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

4207

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

4208

{

4209

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

{

// found a match

break;

}

}

if (tableSize == idx)

4216

{

4217

// did not match the name

4218

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4219

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

4224

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

4225

{

4226

// does not support dynamic configuration

4227

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4228

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

4233

4234

switch (pRegEntry->RegType)

4235

{

4236

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4237

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

4238

if (rv < 0)

4239

goto done;

Jeff Johnson

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

[diff] [blame]

4240

if (value < pRegEntry->VarMin)

4241

{

4242

// out of range

4243

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4244

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4245

goto done;

4246

}

4247

if (value > pRegEntry->VarMax)

4248

{

4249

// out of range

4250

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4251

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4252

goto done;

4253

}

4254

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

4255

break;

4256

4257

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4258

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

4259

if (rv < 0)

4260

goto done;

Jeff Johnson

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

[diff] [blame]

4261

if (value < pRegEntry->VarMin)

4262

{

4263

// out of range

4264

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4265

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4266

goto done;

4267

}

4268

if (value > pRegEntry->VarMax)

4269

{

4270

// out of range

4271

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4272

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4273

goto done;

4274

}

4275

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

4276

break;

4277

4278

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4279

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

4280

if (rv < 0)

4281

goto done;

Jeff Johnson

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

[diff] [blame]

4282

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

4283

{

4284

// out of range

4285

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4286

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

Jeff Johnson

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

[diff] [blame]

4287

goto done;

4288

}

4289

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

4290

{

4291

// out of range

4292

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4293

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

Jeff Johnson

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

[diff] [blame]

4294

goto done;

4295

}

4296

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

4297

break;

4298

4299

case WLAN_PARAM_String:

4300

len_value_str = strlen(value_str);

4301

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

{

// too big

hddLog(LOGE,

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

4306

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4307

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

4308

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

4309

goto done;

4310

}

4311

// copy string plus NUL

4312

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

4313

break;

4314

4315

case WLAN_PARAM_MacAddr:

4316

len_value_str = strlen(value_str);

4317

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

4322

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4323

__func__, value_str,

Jeff Johnson