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

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

[diff] [blame]

2670

#endif

2671

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

2672

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

2673

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

2674

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

2675

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

2676

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

2677

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

2678

2679

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

2680

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

2681

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

2682

#ifdef WLAN_BTAMP_FEATURE

2683

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

2684

#endif //WLAN_BTAMP_FEATURE

2685

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

2686

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

2687

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

2688

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

2689

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

2690

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

2691

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

2692

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

2693

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

2694

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

2695

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

2696

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

2697

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]

2698

#ifdef WLAN_FEATURE_11AC

2699

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

2700

#endif

2701

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

2702

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

2703

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]

2704

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]

2705

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]

2706

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]

2707

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]

2708

Leo Chang

64d68bc

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

[diff] [blame]

2709

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

2710

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]

2714

Jeff Johnson

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

[diff] [blame]

2715

#define CFG_VALUE_MAX_LEN 256

2716

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2717

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

2718

{

2719

unsigned int idx;

2720

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2721

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

2722

v_U32_t value;

2723

char valueStr[CFG_VALUE_MAX_LEN];

2724

char configStr[CFG_ENTRY_MAX_LEN];

2725

char *fmt;

2726

void *pField;

2727

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2732

*pCur = '\0';

2733

Kiran Kumar Lokere

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

[diff] [blame]

2734

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

Jeff Johnson

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

[diff] [blame]

2735

{

2736

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

2737

2738

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

2739

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

Kiran Kumar Lokere

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

[diff] [blame]

2740

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

Jeff Johnson

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

[diff] [blame]

2741

{

2742

value = 0;

2743

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

2744

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

2757

}

2758

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2759

{

2760

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

2761

}

2762

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2763

{

2764

pMacAddr = (v_MACADDR_t *) pField;

2765

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2766

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

2777

}

2778

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2783

"*" : "");

2784

2785

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

2786

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

2787

#ifdef RETURN_IN_BUFFER

2788

if (curlen <= buflen)

2789

{

2790

// copy string + '\0'

2791

memcpy(pCur, configStr, curlen+1);

2792

2793

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2800

return VOS_STATUS_E_RESOURCES;

2801

}

2802

#else

2803

printk(KERN_CRIT "%s", configStr);

2804

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2809

// notify application that output is in system log

2810

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

2811

#endif // RETURN_IN_BUFFER

2812

2813

return VOS_STATUS_SUCCESS;

2814

}

2815

2816

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

Kiran Kumar Lokere

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

[diff] [blame]

2817

char *name, char** value)

Jeff Johnson

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

[diff] [blame]

2818

{

2819

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2820

unsigned long i;

2821

2822

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

2823

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

2824

*value = iniTable[i].value;

2825

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

2826

WLAN_INI_FILE, name, *value);

2827

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2835

{

2836

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

2837

return c-'0';

2838

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

2839

return c-'a'+10;

2840

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)

2848

{

2849

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2850

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2851

unsigned int idx;

2852

void *pField;

2853

char *value_str = NULL;

2854

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2859

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2860

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

2861

v_U32_t cbOutString;

2862

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2863

int rv;

Jeff Johnson

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

[diff] [blame]

2864

2865

// sanity test

2866

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2867

{

2868

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]

2869

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2870

}

2871

2872

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

2873

{

2874

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

2875

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

2876

2877

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

2878

2879

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

2880

{

2881

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

2882

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2883

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2884

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2889

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2890

{

2891

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

2892

// If not, use the default value.

2893

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2894

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

2895

if (rv < 0) {

2896

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

2897

__func__, pRegEntry->RegName);

2898

value = pRegEntry->VarDefault;

2899

}

Jeff Johnson

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

[diff] [blame]

2900

}

2901

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2902

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

2903

if (rv < 0) {

2904

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

2905

__func__, pRegEntry->RegName);

2906

value = pRegEntry->VarDefault;

2907

}

Jeff Johnson

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

[diff] [blame]

2908

}

2909

else {

2910

value = pRegEntry->VarDefault;

2911

}

2912

2913

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

2914

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2915

{

2916

if ( value > pRegEntry->VarMax )

2917

{

2918

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2919

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

Jeff Johnson

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

[diff] [blame]

2920

value = pRegEntry->VarMax;

2921

}

2922

2923

if ( value < pRegEntry->VarMin )

2924

{

2925

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2926

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

Jeff Johnson

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

[diff] [blame]

2927

value = pRegEntry->VarMin;

2928

}

2929

}

2930

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

2931

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2932

{

2933

if ( value > pRegEntry->VarMax )

2934

{

2935

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]

2936

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

Jeff Johnson

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

[diff] [blame]

2937

value = pRegEntry->VarDefault;

2938

}

2939

2940

if ( value < pRegEntry->VarMin )

2941

{

2942

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]

2943

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

Jeff Johnson

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

[diff] [blame]

2944

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2949

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

2950

}

2951

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2952

{

2953

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

2954

// If not, use the default value.

2955

if (VOS_STATUS_SUCCESS == match_status)

2956

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2957

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

2958

if (rv < 0) {

2959

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

2960

__func__, pRegEntry->RegName);

2961

svalue = (v_S31_t)pRegEntry->VarDefault;

2962

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2967

}

2968

2969

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

2970

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2971

{

2972

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

2973

{

2974

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2975

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

Jeff Johnson

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

[diff] [blame]

2976

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

2977

svalue = (v_S31_t)pRegEntry->VarMax;

2978

}

2979

2980

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

2981

{

2982

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2983

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

Jeff Johnson

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

[diff] [blame]

2984

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

2985

svalue = (v_S31_t)pRegEntry->VarMin;

2986

}

2987

}

2988

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

2989

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2990

{

2991

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

2992

{

2993

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

2994

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2995

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2996

(int)pRegEntry->VarMax,

2997

(int)pRegEntry->VarDefault );

2998

svalue = (v_S31_t)pRegEntry->VarDefault;

2999

}

3000

3001

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

3002

{

3003

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

3004

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3005

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

3006

(int)pRegEntry->VarMin,

3007

(int)pRegEntry->VarDefault);

3008

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

3013

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

3014

}

3015

// Handle string parameters

3016

else if ( WLAN_PARAM_String == pRegEntry->RegType )

3017

{

3018

#ifdef WLAN_CFG_DEBUG

3019

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]

3020

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

Jeff Johnson

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

[diff] [blame]

3021

#endif

3022

Kiran Kumar Lokere

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

[diff] [blame]

3023

if ( match_status == VOS_STATUS_SUCCESS)

Jeff Johnson

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

[diff] [blame]

3024

{

3025

len_value_str = strlen(value_str);

3026

3027

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

Kiran Kumar Lokere

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

[diff] [blame]

3028

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]

3029

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

Jeff Johnson

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

[diff] [blame]

3030

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

3031

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

3032

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

}

else

{

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

3037

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

3038

}

3039

}

Kiran Kumar Lokere

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

[diff] [blame]

3040

else

Jeff Johnson

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

[diff] [blame]

3041

{

3042

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

3043

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

3044

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

Kiran Kumar Lokere

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

[diff] [blame]

3045

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

Jeff Johnson

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

[diff] [blame]

3046

}

3047

}

3048

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

3049

{

3050

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

Kiran Kumar Lokere

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

[diff] [blame]

3051

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

3052

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

Jeff Johnson

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

[diff] [blame]

3053

continue;

3054

}

3055

candidate = (char*)pRegEntry->VarDefault;

3056

if ( match_status == VOS_STATUS_SUCCESS) {

3057

len_value_str = strlen(value_str);

3058

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

Kiran Kumar Lokere

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

[diff] [blame]

3059

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]

3060

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

Jeff Johnson

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

[diff] [blame]

3061

}

3062

else

3063

candidate = value_str;

3064

}

3065

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

3066

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

3067

{

Kiran Kumar Lokere

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

[diff] [blame]

3068

((char*)pField)[i] =

3069

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

3074

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]

3075

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

3076

}

3077

3078

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

3079

if( (match_status == VOS_STATUS_SUCCESS) &&

3080

(idx < MAX_CFG_INI_ITEMS) )

3081

{

3082

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

}

}

print_hdd_cfg(pHddCtx);

3087

3088

return( ret_status );

3089

}

3090

3091

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

3092

{

Kiran Kumar Lokere

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

[diff] [blame]

3093

switch (dot11Mode)

Jeff Johnson

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

[diff] [blame]

3094

{

3095

case (eHDD_DOT11_MODE_abg):

3096

return eCSR_DOT11_MODE_abg;

3097

case (eHDD_DOT11_MODE_11b):

3098

return eCSR_DOT11_MODE_11b;

3099

case (eHDD_DOT11_MODE_11g):

3100

return eCSR_DOT11_MODE_11g;

3101

default:

3102

case (eHDD_DOT11_MODE_11n):

3103

return eCSR_DOT11_MODE_11n;

3104

case (eHDD_DOT11_MODE_11g_ONLY):

3105

return eCSR_DOT11_MODE_11g_ONLY;

3106

case (eHDD_DOT11_MODE_11n_ONLY):

3107

return eCSR_DOT11_MODE_11n_ONLY;

3108

case (eHDD_DOT11_MODE_11b_ONLY):

3109

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

3110

#ifdef WLAN_FEATURE_11AC

3111

case (eHDD_DOT11_MODE_11ac_ONLY):

3112

return eCSR_DOT11_MODE_11ac_ONLY;

3113

case (eHDD_DOT11_MODE_11ac):

3114

return eCSR_DOT11_MODE_11ac;

3115

#endif

Jeff Johnson

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

[diff] [blame]

3116

case (eHDD_DOT11_MODE_AUTO):

3117

return eCSR_DOT11_MODE_AUTO;

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3122

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

Jeff Johnson

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

[diff] [blame]

3123

{

3124

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3125

tSmeBtcConfig btcParams;

Kiran Kumar Lokere

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

[diff] [blame]

3126

Jeff Johnson

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

[diff] [blame]

3127

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

3128

3129

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

3130

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

3131

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

3132

Jeff Johnson

32d95a3

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

[diff] [blame]

3133

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

3134

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

3135

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

3136

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

3137

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

3138

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

3139

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

3140

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

3141

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

3142

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

3143

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

3144

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

3145

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

3146

Jeff Johnson

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

[diff] [blame]

3147

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

3148

}

3149

Kiran Kumar Lokere

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

[diff] [blame]

3150

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

Jeff Johnson

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

[diff] [blame]

3151

{

3152

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3153

3154

tPmcBmpsConfigParams bmpsParams;

Kiran Kumar Lokere

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

[diff] [blame]

3155

Jeff Johnson

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

[diff] [blame]

3156

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

Kiran Kumar Lokere

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

[diff] [blame]

3157

Jeff Johnson

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

[diff] [blame]

3158

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

3159

{

3160

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

3161

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

3162

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3163

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3164

}

3165

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

3166

{

3167

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

3168

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

3169

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3170

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3171

}

3172

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

3173

{

3174

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

3175

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

3176

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

3177

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

3178

}

3179

3180

if (pConfig->fIsImpsEnabled)

3181

{

3182

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

3187

}

3188

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

3189

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

3190

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

3191

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

3192

Jeff Johnson

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

[diff] [blame]

3193

if (pConfig->fIsBmpsEnabled)

3194

{

3195

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

3200

}

3201

3202

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

3203

3204

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

3205

{

3206

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

3207

}

Kiran Kumar Lokere

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

[diff] [blame]

3208

Jeff Johnson

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

[diff] [blame]

3209

if(pConfig->fIsAutoBmpsTimerEnabled)

3210

{

3211

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3217

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 )

3222

{

3223

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

3227

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

3228

{

3229

int val;

3230

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

3231

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

3232

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

3233

{

3234

intArray[*len] = (tANI_U8) val;

3235

*len += 1;

3236

}

3237

s = strpbrk( s, "," );

3238

if( s )

3239

s++;

3240

}

Jeff Johnson

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

[diff] [blame]

3241

3242

return VOS_STATUS_SUCCESS;

Kiran Kumar Lokere

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

[diff] [blame]

3243

Jeff Johnson

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

[diff] [blame]

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

3249

{

3250

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

3251

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3252

tANI_U32 val;

3253

#endif

Jeff Johnson

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

[diff] [blame]

3254

3255

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

3256

tSirMacHTCapabilityInfo htCapInfo;

3257

Jeff Johnson

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

[diff] [blame]

3258

Kiran Kumar Lokere

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

[diff] [blame]

3259

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

Jeff Johnson

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

[diff] [blame]

3260

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

3261

{

3262

fStatus = FALSE;

3263

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

3264

}

Kiran Kumar Lokere

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

[diff] [blame]

3265

3266

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

Jeff Johnson

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

[diff] [blame]

3267

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3268

{

3269

fStatus = FALSE;

3270

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

3271

}

3272

3273

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

3274

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3275

{

3276

fStatus = FALSE;

3277

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

3278

}

3279

3280

if ( 0 != pConfig->Cfg1Id )

3281

{

Kiran Kumar Lokere

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

[diff] [blame]

3282

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

Jeff Johnson

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

[diff] [blame]

3283

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3284

{

3285

fStatus = FALSE;

3286

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

3287

}

Kiran Kumar Lokere

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

[diff] [blame]

3288

Jeff Johnson

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

[diff] [blame]

3289

}

3290

3291

if ( 0 != pConfig->Cfg2Id )

3292

{

Kiran Kumar Lokere

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

[diff] [blame]

3293

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

Jeff Johnson

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

[diff] [blame]

3294

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3295

{

3296

fStatus = FALSE;

3297

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

}

}

if ( 0 != pConfig->Cfg3Id )

3302

{

Kiran Kumar Lokere

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

[diff] [blame]

3303

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

Jeff Johnson

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

[diff] [blame]

3304

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3305

{

3306

fStatus = FALSE;

3307

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

}

}

if ( 0 != pConfig->Cfg4Id )

3312

{

Kiran Kumar Lokere

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

[diff] [blame]

3313

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

Jeff Johnson

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

[diff] [blame]

3314

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3315

{

3316

fStatus = FALSE;

3317

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

}

}

if ( 0 != pConfig->Cfg5Id )

3322

{

Kiran Kumar Lokere

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

[diff] [blame]

3323

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

Jeff Johnson

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

[diff] [blame]

3324

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3325

{

3326

fStatus = FALSE;

3327

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

}

}

Kiran Kumar Lokere

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

[diff] [blame]

3331

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

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 WNI_CFG_BA_AUTO_SETUP to CCM\n");

3336

}

Kiran Kumar Lokere

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

[diff] [blame]

3337

3338

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

Jeff Johnson

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

[diff] [blame]

3339

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3340

{

3341

fStatus = FALSE;

3342

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

3343

}

3344

Kiran Kumar Lokere

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

[diff] [blame]

3345

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

Jeff Johnson

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

[diff] [blame]

3346

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

3347

{

3348

fStatus = FALSE;

3349

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

3350

}

3351

3352

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

3353

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3354

{

3355

fStatus = FALSE;

3356

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

3357

}

3358

Kiran Kumar Lokere

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

[diff] [blame]

3359

if (pConfig->fIsAutoIbssBssid)

Jeff Johnson

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

[diff] [blame]

3360

{

Kiran Kumar Lokere

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

[diff] [blame]

3361

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

Jeff Johnson

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

[diff] [blame]

3362

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

3363

{

3364

fStatus = FALSE;

3365

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

3366

}

3367

}

3368

else

Kiran Kumar Lokere

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

[diff] [blame]

3369

{

Jeff Johnson

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

[diff] [blame]

3370

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

3371

{

3372

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3373

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

3374

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

Jeff Johnson

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

[diff] [blame]

3375

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

Kiran Kumar Lokere

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

[diff] [blame]

3376

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

Jeff Johnson

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

[diff] [blame]

3377

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

3378

{

3379

fStatus = FALSE;

3380

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]

3390

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

Jeff Johnson

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

[diff] [blame]

3391

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3392

{

3393

fStatus = FALSE;

3394

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

3395

}

3396

Kiran Kumar Lokere

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

[diff] [blame]

3397

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

Jeff Johnson

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

[diff] [blame]

3398

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3399

{

3400

fStatus = FALSE;

3401

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

3402

}

3403

3404

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

3405

{

3406

fStatus = FALSE;

3407

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

3408

}

3409

Kiran Kumar Lokere

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

[diff] [blame]

3410

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

Jeff Johnson

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

[diff] [blame]

3411

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3412

{

3413

fStatus = FALSE;

3414

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

3415

}

Kiran Kumar Lokere

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

[diff] [blame]

3416

Jeff Johnson

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

[diff] [blame]

3417

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

3418

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3419

{

3420

fStatus = FALSE;

3421

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

3422

}

3423

Jeff Johnson

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

[diff] [blame]

3424

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

3425

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3426

{

3427

fStatus = FALSE;

3428

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

3429

}

3430

Kiran Kumar Lokere

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

[diff] [blame]

3431

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

Jeff Johnson

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

[diff] [blame]

3432

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3433

{

3434

fStatus = FALSE;

3435

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

3436

}

3437

Kiran Kumar Lokere

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

[diff] [blame]

3438

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

Jeff Johnson

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

[diff] [blame]

3439

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3440

{

3441

fStatus = FALSE;

3442

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

3443

}

3444

Gopichand Nakkala

98a98af

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

[diff] [blame]

3445

#ifdef FEATURE_WLAN_LFR

3446

if (pConfig->isFastRoamIniFeatureEnabled)

3447

{

3448

pConfig->fEnableFwRssiMonitoring = TRUE;

3449

}

3450

#endif

3451

#ifdef FEATURE_WLAN_CCX

3452

if (pConfig->isCcxIniFeatureEnabled)

3453

{

3454

pConfig->fEnableFwRssiMonitoring = TRUE;

3455

}

3456

#endif

Kiran Kumar Lokere

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

[diff] [blame]

3457

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

Jeff Johnson

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

[diff] [blame]

3458

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3459

{

3460

fStatus = FALSE;

3461

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

3462

}

3463

Kiran Kumar Lokere

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

[diff] [blame]

3464

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

Jeff Johnson

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

[diff] [blame]

3465

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3466

{

3467

fStatus = FALSE;

3468

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

3469

}

3470

Kiran Kumar Lokere

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

[diff] [blame]

3471

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

Jeff Johnson

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

[diff] [blame]

3472

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3473

{

3474

fStatus = FALSE;

3475

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

3476

}

3477

Kiran Kumar Lokere

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

[diff] [blame]

3478

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

Jeff Johnson

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

[diff] [blame]

3479

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3480

{

3481

fStatus = FALSE;

3482

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

3483

}

3484

Kiran Kumar Lokere

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

[diff] [blame]

3485

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

Jeff Johnson

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

[diff] [blame]

3486

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3487

{

3488

fStatus = FALSE;

3489

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

3490

}

3491

Kiran Kumar Lokere

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

[diff] [blame]

3492

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

Jeff Johnson

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

[diff] [blame]

3493

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3494

{

3495

fStatus = FALSE;

3496

hddLog(LOGE, "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]

3497

}

Jeff Johnson

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

[diff] [blame]

3498

Kiran Kumar Lokere

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

[diff] [blame]

3499

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

Jeff Johnson

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

[diff] [blame]

3500

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3501

{

3502

fStatus = FALSE;

3503

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

3504

}

Kiran Kumar Lokere

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

[diff] [blame]

3505

Sejal Chauhan

bcde8bc

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

[diff] [blame]

3506

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

3507

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3508

{

3509

fStatus = FALSE;

3510

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

3511

}

3512

Jeff Johnson

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

[diff] [blame]

3513

#if defined WLAN_FEATURE_VOWIFI

Kiran Kumar Lokere

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

[diff] [blame]

3514

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

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,"Failure: Could not pass on WNI_CFG_RRM_ENABLE configuration info to CCM\n");

3519

}

3520

Kiran Kumar Lokere

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

[diff] [blame]

3521

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

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,"Failure: Could not pass on WNI_CFG_RRM_OPERATING_CHAN_MAX configuration info to CCM\n");

3526

}

3527

Kiran Kumar Lokere

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

[diff] [blame]

3528

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

Jeff Johnson

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

[diff] [blame]

3529

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3530

{

3531

fStatus = FALSE;

3532

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

3533

}

3534

Kiran Kumar Lokere

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

[diff] [blame]

3535

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

Jeff Johnson

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

[diff] [blame]

3536

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3537

#endif

3538

Kiran Kumar Lokere

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

[diff] [blame]

3539

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

Jeff Johnson

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

[diff] [blame]

3540

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3541

{

3542

fStatus = FALSE;

3543

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

3544

}

3545

Kiran Kumar Lokere

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

[diff] [blame]

3546

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

Jeff Johnson

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

[diff] [blame]

3547

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3548

{

3549

fStatus = FALSE;

3550

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

3551

}

3552

Kiran Kumar Lokere

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

[diff] [blame]

3553

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

Jeff Johnson

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

[diff] [blame]

3554

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3555

{

3556

fStatus = FALSE;

3557

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

3558

}

3559

Kiran Kumar Lokere

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

[diff] [blame]

3560

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

Jeff Johnson

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

[diff] [blame]

3561

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3562

{

3563

fStatus = FALSE;

3564

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

3565

}

3566

Kiran Kumar Lokere

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

[diff] [blame]

3567

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]

3568

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3569

{

3570

fStatus = FALSE;

3571

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

3572

}

3573

Kiran Kumar Lokere

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

[diff] [blame]

3574

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]

3575

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3576

{

3577

fStatus = FALSE;

3578

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

3579

}

3580

3581

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

3582

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3583

{

3584

fStatus = FALSE;

3585

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

3586

}

3587

Kiran Kumar Lokere

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

[diff] [blame]

3588

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

Jeff Johnson

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

[diff] [blame]

3589

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3590

{

3591

fStatus = FALSE;

3592

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

3593

}

Kiran Kumar Lokere

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

[diff] [blame]

3594

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

Jeff Johnson

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

[diff] [blame]

3595

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3596

{

3597

fStatus = FALSE;

3598

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

3599

}

3600

3601

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

3602

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3603

{

3604

fStatus = FALSE;

3605

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]

3606

}

Jeff Johnson

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

[diff] [blame]

3607

Jeff Johnson

eed2dca

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

[diff] [blame]

3608

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

Jeff Johnson

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

[diff] [blame]

3609

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

Jeff Johnson

eed2dca

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

[diff] [blame]

3610

{

3611

fStatus = FALSE;

3612

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

3613

}

Kiran Kumar Lokere

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

[diff] [blame]

3614

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

Jeff Johnson

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

[diff] [blame]

3615

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3616

{

3617

fStatus = FALSE;

3618

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

3619

}

Kiran Kumar Lokere

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

[diff] [blame]

3620

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

Jeff Johnson

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

[diff] [blame]

3621

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3622

{

3623

fStatus = FALSE;

3624

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

3625

}

3626

Kiran Kumar Lokere

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

[diff] [blame]

3627

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

Jeff Johnson

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

[diff] [blame]

3628

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3629

{

3630

fStatus = FALSE;

3631

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

3632

}

Kiran Kumar Lokere

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

[diff] [blame]

3633

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

Jeff Johnson

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

[diff] [blame]

3634

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3635

{

3636

fStatus = FALSE;

3637

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

3638

}

3639

Jeff Johnson

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

[diff] [blame]

3640

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

3641

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3642

{

3643

fStatus = FALSE;

3644

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

3645

}

3646

Kiran Kumar Lokere

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

[diff] [blame]

3647

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

Jeff Johnson

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

[diff] [blame]

3648

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3649

==eHAL_STATUS_FAILURE)

3650

{

3651

fStatus = FALSE;

3652

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

3653

}

3654

Kiran Kumar Lokere

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

[diff] [blame]

3655

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

Jeff Johnson

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

[diff] [blame]

3656

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3657

==eHAL_STATUS_FAILURE)

3658

{

3659

fStatus = FALSE;

3660

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

3661

}

3662

Kiran Kumar Lokere

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

[diff] [blame]

3663

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

Jeff Johnson

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

[diff] [blame]

3664

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

3665

{

3666

fStatus = FALSE;

3667

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

3668

}

3669

Jeff Johnson

d13512a

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

[diff] [blame]

3670

Kiran Kumar Lokere

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

[diff] [blame]

3671

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

Jeff Johnson

d13512a

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

[diff] [blame]

3672

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3673

{

3674

fStatus = FALSE;

3675

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

3676

}

3677

Jeff Johnson

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

[diff] [blame]

3678

#ifdef WLAN_FEATURE_11AC

3679

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

3680

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

3681

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

3682

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

3683

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3684

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

3690

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

Jeff Johnson

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

[diff] [blame]

3691

Kiran Kumar Lokere

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

[diff] [blame]

3692

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

Jeff Johnson

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

[diff] [blame]

3693

temp, NULL, eANI_BOOLEAN_FALSE)

3694

==eHAL_STATUS_FAILURE)

3695

{

3696

fStatus = FALSE;

3697

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

3698

}

3699

3700

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

Kiran Kumar Lokere

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

[diff] [blame]

3701

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

Jeff Johnson

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

[diff] [blame]

3702

Kiran Kumar Lokere

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

[diff] [blame]

3703

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

Jeff Johnson

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

[diff] [blame]

3704

temp, NULL, eANI_BOOLEAN_FALSE)

3705

==eHAL_STATUS_FAILURE)

3706

{

3707

fStatus = FALSE;

3708

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

3709

}

3710

3711

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

Kiran Kumar Lokere

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

[diff] [blame]

3712

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

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_TX_MCS_MAP,

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_TX_MCS_MAP to CCM\n");

}

}

}

#endif

Kiran Kumar Lokere

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

[diff] [blame]

3725

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

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

3726

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3727

{

3728

fStatus = FALSE;

3729

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

3730

}

3731

Kiran Kumar Lokere

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

[diff] [blame]

3732

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

Pratik Bhalgat

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

[diff] [blame]

3733

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3734

==eHAL_STATUS_FAILURE)

3735

{

3736

fStatus = FALSE;

3737

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

3738

}

3739

3740

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

3741

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3742

Kiran Kumar Lokere

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

[diff] [blame]

3743

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

Pratik Bhalgat

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

[diff] [blame]

3744

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

3745

==eHAL_STATUS_FAILURE)

3746

{

3747

fStatus = FALSE;

3748

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

3749

}

3750

Kiran Kumar Lokere

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

[diff] [blame]

3751

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

Pratik Bhalgat

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

[diff] [blame]

3752

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3753

==eHAL_STATUS_FAILURE)

3754

{

3755

fStatus = FALSE;

3756

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

3757

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3758

3759

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3760

if(pConfig->fEnableVSTASupport)

3761

{

3762

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

3763

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3764

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3769

}

Kiran Kumar Lokere

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

[diff] [blame]

3770

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

Gopichand Nakkala

976e325

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

[diff] [blame]

3771

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3772

{

3773

fStatus = FALSE;

3774

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

3775

}

3776

#endif

Kiran Kumar Lokere

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

[diff] [blame]

3777

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3778

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3779

==eHAL_STATUS_FAILURE)

3780

{

3781

fStatus = FALSE;

3782

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

3783

}

Pratik Bhalgat

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

[diff] [blame]

3784

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3785

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

3786

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3787

{

3788

fStatus = FALSE;

3789

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

3790

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

3791

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

3792

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3793

{

3794

fStatus = FALSE;

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

3795

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]

3796

}

Kiran Kumar Lokere

1f39e95

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

[diff] [blame]

3797

3798

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

3799

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3800

{

3801

fStatus = FALSE;

3802

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

3803

}

3804

3805

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

3806

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3807

{

3808

fStatus = FALSE;

3809

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

3810

}

3811

3812

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

3813

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3814

{

3815

fStatus = FALSE;

3816

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

3817

}

3818

Gopichand Nakkala

42bc89e

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

[diff] [blame]

3819

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

3820

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3821

{

3822

fStatus = FALSE;

3823

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

3824

}

3825

Gopichand Nakkala

79ff85d

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

[diff] [blame]

3826

#ifdef FEATURE_WLAN_TDLS

3827

3828

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

3829

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3830

{

3831

fStatus = FALSE;

3832

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

3833

}

3834

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

3835

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3836

{

3837

fStatus = FALSE;

3838

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

3839

}

3840

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

3841

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3842

{

3843

fStatus = FALSE;

3844

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

3845

}

3846

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

3847

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3848

{

3849

fStatus = FALSE;

3850

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;

}

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

3859

Kiran Kumar Lokere

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

[diff] [blame]

3860

\brief hdd_init_set_sme_config() -

Jeff Johnson

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

[diff] [blame]

3861

3862

This function initializes the sme configuration parameters

Kiran Kumar Lokere

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

[diff] [blame]

3863

Jeff Johnson

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

[diff] [blame]

3864

\param - pHddCtx - Pointer to the HDD Adapter.

Kiran Kumar Lokere

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

[diff] [blame]

3865

Jeff Johnson

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

[diff] [blame]

3866

\return - 0 for success, non zero for failure

Kiran Kumar Lokere

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

[diff] [blame]

3867

Jeff Johnson

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

[diff] [blame]

3868

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

3869

3870

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3871

{

3872

VOS_STATUS status = VOS_STATUS_SUCCESS;

3873

eHalStatus halStatus;

3874

tSmeConfigParams smeConfig;

3875

3876

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3877

3878

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3879

Kiran Kumar Lokere

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

[diff] [blame]

3880

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

Jeff Johnson

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

[diff] [blame]

3881

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

3882

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

3883

3884

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3885

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3886

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

Jeff Johnson

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

[diff] [blame]

3887

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3888

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3889

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3890

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3891

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3892

3893

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

3894

3895

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3896

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3897

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3898

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3899

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3900

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3901

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3902

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3903

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3904

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3905

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3906

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3907

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3908

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3909

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3910

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3911

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

Kiran Kumar Lokere

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

[diff] [blame]

3912

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

Jeff Johnson

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

[diff] [blame]

3913

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3914

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3915

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3916

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Kiran Kumar Lokere

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

[diff] [blame]

3917

smeConfig.csrConfig.nActiveMaxChnTimeBtc = pConfig->nActiveMaxChnTimeBtc;

3918

smeConfig.csrConfig.nActiveMinChnTimeBtc = pConfig->nActiveMinChnTimeBtc;

Kiran Kumar Lokere

458d732

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

[diff] [blame]

3919

smeConfig.csrConfig.disableAggWithBtc = pConfig->disableAggWithBtc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3920

#ifdef WLAN_AP_STA_CONCURRENCY

3921

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3922

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3923

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3924

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3925

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Sudhir Sattayappa Kohalli

eb97d50

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

[diff] [blame]

3926

smeConfig.csrConfig.nNumStaChanCombinedConc = pConfig->nNumStaChanCombinedConc;

3927

smeConfig.csrConfig.nNumP2PChanCombinedConc = pConfig->nNumP2PChanCombinedConc;

3928

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3929

#endif

Jeff Johnson

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

[diff] [blame]

3930

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3931

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3932

3933

#if defined WLAN_FEATURE_VOWIFI

3934

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3935

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3936

#endif

3937

//Remaining config params not obtained from registry

3938

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3939

#ifdef WLAN_FEATURE_11AC

3940

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

3941

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

3942

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Ravi Joshi

83bfaa1

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

[diff] [blame]

3943

smeConfig.csrConfig.enableVhtFor24GHz = pConfig->enableVhtFor24GHzBand;

Jeff Johnson

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

[diff] [blame]

3944

#endif

Shailender Karmuchi

a734f33

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

[diff] [blame]

3945

smeConfig.csrConfig.AdHocChannel5G = pConfig->AdHocChannel5G;

3946

smeConfig.csrConfig.AdHocChannel24 = pConfig->AdHocChannel24G;

Kiran Kumar Lokere

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

[diff] [blame]

3947

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3948

smeConfig.csrConfig.HeartbeatThresh50 = 40;

3949

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3950

if (pConfig->nBandCapability == eCSR_BAND_24)

3951

{

3952

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3953

} else {

3954

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3955

}

Kiran Kumar Lokere

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

[diff] [blame]

3956

smeConfig.csrConfig.cbChoice = 0;

3957

smeConfig.csrConfig.bgScanInterval = 0;

3958

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

Jeff Johnson

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

[diff] [blame]

3959

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3960

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3961

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3962

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

3963

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

Srinivas Girigowda

bbd16eb

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

[diff] [blame]

3964

smeConfig.csrConfig.nRoamIntraBand = pConfig->nRoamIntraBand;

Varun Reddy Yeturu

920df21

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

[diff] [blame]

3965

smeConfig.csrConfig.nProbes = pConfig->nProbes;

3966

smeConfig.csrConfig.nRoamScanHomeAwayTime = pConfig->nRoamScanHomeAwayTime;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3967

#endif

Jeff Johnson

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

[diff] [blame]

3968

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3969

Jeff Johnson

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

[diff] [blame]

3970

//FIXME 11d config is hardcoded

Jeff Johnson

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

[diff] [blame]

3971

if ( VOS_STA_SAP_MODE != hdd_get_conparam())

3972

{

3973

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

Jeff Johnson

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

[diff] [blame]

3974

Jeff Johnson

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

[diff] [blame]

3975

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

3976

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

3977

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

3978

* come from NV as per our current implementation */

Jeff Johnson

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

[diff] [blame]

3979

}

Jeff Johnson

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

[diff] [blame]

3980

else

3981

{

3982

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3983

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

Jeff Johnson

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

[diff] [blame]

3984

Jeff Johnson

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

[diff] [blame]

3985

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

3986

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

3987

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3988

}

Jeff Johnson

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

[diff] [blame]

3989

hdd_set_power_save_config(pHddCtx, &smeConfig);

3990

hdd_set_btc_config(pHddCtx);

3991

Kiran Kumar Lokere

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

[diff] [blame]

3992

#ifdef WLAN_FEATURE_VOWIFI_11R

Jeff Johnson

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

[diff] [blame]

3993

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

3994

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3995

#ifdef FEATURE_WLAN_LFR

3996

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3997

if( pConfig->isFastRoamIniFeatureEnabled )

3998

{

3999

pConfig->isFastTransitionEnabled = TRUE;

4000

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

4001

#endif

Jeff Johnson

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

[diff] [blame]

4002

#ifdef FEATURE_WLAN_CCX

4003

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

4004

if( pConfig->isCcxIniFeatureEnabled )

4005

{

4006

pConfig->isFastTransitionEnabled = TRUE;

4007

}

Jeff Johnson

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

[diff] [blame]

4008

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

4009

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

4010

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

4011

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

4012

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Srinivas Girigowda

100eb32

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

[diff] [blame]

4013

smeConfig.csrConfig.isWESModeEnabled = pConfig->isWESModeEnabled;

Jeff Johnson

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

[diff] [blame]

4014

#endif

Varun Reddy Yeturu

d0a3f25

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

[diff] [blame]

4015

#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD

4016

smeConfig.csrConfig.isRoamOffloadScanEnabled = pConfig->isRoamOffloadScanEnabled;

4017

#endif

Jeff Johnson

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

[diff] [blame]

4018

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

4019

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

4020

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

Kiran Kumar Lokere

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

[diff] [blame]

4021

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

4022

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

Jeff Johnson

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

[diff] [blame]

4023

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

Kiran Kumar Lokere

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

[diff] [blame]

4024

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

Jeff Johnson

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

[diff] [blame]

4025

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

Srinivas Girigowda

de69741

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

[diff] [blame]

4026

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

Kiran Kumar Lokere

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

[diff] [blame]

4027

hdd_string_to_u8_array( pConfig->neighborScanChanList,

4028

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

4029

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

Jeff Johnson

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

[diff] [blame]

4030

WNI_CFG_VALID_CHANNEL_LIST_LEN );

4031

#endif

4032

4033

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

4034

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

4035

Kiran Kumar Lokere

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

[diff] [blame]

4036

//Enable/Disable MCC

Jeff Johnson

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

[diff] [blame]

4037

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

4038

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

4039

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

4040

//Scan Results Aging Time out value

4041

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

4042

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

4043

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

4044

Gopichand Nakkala

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

[diff] [blame]

4045

/* update SSR config */

4046

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

Gopichand Nakkala

86e4266

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

[diff] [blame^]

4047

/* Update the Directed scan offload setting */

4048

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

Gopichand Nakkala

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

[diff] [blame]

4049

Kiran Kumar Lokere

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

[diff] [blame]

4050

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

Jeff Johnson

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

[diff] [blame]

4051

if ( !HAL_STATUS_SUCCESS( halStatus ) )

4052

{

4053

status = VOS_STATUS_E_FAILURE;

4054

}

4055

Kiran Kumar Lokere

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

[diff] [blame]

4056

4057

return status;

Jeff Johnson

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

[diff] [blame]

}

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

4062

4063

\brief hdd_execute_config_command() -

4064

4065

This function executes an arbitrary configuration set command

4066

4067

\param - pHddCtx - Pointer to the HDD Adapter.

4068

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

4069

4070

4071

\return - 0 for success, non zero for failure

4072

4073

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

4074

4075

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

4076

{

4077

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

4078

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;

4087

unsigned int idx;

4088

unsigned int i;

4089

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

4090

int rv;

Jeff Johnson

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

[diff] [blame]

4091

4092

// assume failure until proven otherwise

4093

vstatus = VOS_STATUS_E_FAILURE;

4094

4095

// clone the command so that we can manipulate it

4096

clone = kstrdup(command, GFP_ATOMIC);

4097

if (NULL == clone)

4098

{

4099

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4100

__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

4105

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

4106

pCmd = clone;

4107

4108

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

4114

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

4119

name = pCmd;

4120

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]

4128

__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

4138

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4139

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

4144

if ('\0' == *value_str)

4145

{

4146

// did not find a value

4147

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4148

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

4153

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

4154

{

4155

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

{

// found a match

break;

}

}

if (tableSize == idx)

4162

{

4163

// did not match the name

4164

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4165

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

4170

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

4171

{

4172

// does not support dynamic configuration

4173

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4174

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

4179

4180

switch (pRegEntry->RegType)

4181

{

4182

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4183

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

4184

if (rv < 0)

4185

goto done;

Jeff Johnson

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

[diff] [blame]

4186

if (value < pRegEntry->VarMin)

4187

{

4188

// out of range

4189

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4190

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4191

goto done;

4192

}

4193

if (value > pRegEntry->VarMax)

4194

{

4195

// out of range

4196

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4197

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4198

goto done;

4199

}

4200

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

4201

break;

4202

4203

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4204

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

4205

if (rv < 0)

4206

goto done;

Jeff Johnson

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

[diff] [blame]

4207

if (value < pRegEntry->VarMin)

4208

{

4209

// out of range

4210

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4211

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

4212

goto done;

4213

}

4214

if (value > pRegEntry->VarMax)

4215

{

4216

// out of range

4217

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4218

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

4219

goto done;

4220

}

4221

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

4222

break;

4223

4224

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

4225

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

4226

if (rv < 0)

4227

goto done;

Jeff Johnson

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

[diff] [blame]

4228

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

4229

{

4230

// out of range

4231

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4232

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

Jeff Johnson

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

[diff] [blame]

4233

goto done;

4234

}

4235

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

4236

{

4237

// out of range

4238

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

4239

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

Jeff Johnson

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

[diff] [blame]

4240

goto done;

4241

}

4242

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

4243

break;

4244

4245

case WLAN_PARAM_String:

4246

len_value_str = strlen(value_str);

4247

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

{

// too big

hddLog(LOGE,

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

4252

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4253

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

4254

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

4255

goto done;

4256

}

4257

// copy string plus NUL

4258

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

4259

break;

4260

4261

case WLAN_PARAM_MacAddr:

4262

len_value_str = strlen(value_str);

4263

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

4268

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

4269

__func__, value_str,

Jeff Johnson