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

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

[diff] [blame]

2050

#ifdef WLAN_FEATURE_11AC

2051

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

2052

#endif

2053

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

2054

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

2055

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

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame^]

2056

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

Jeff Johnson

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

[diff] [blame]

}

#define CFG_VALUE_MAX_LEN 256

2061

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2062

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

2063

{

2064

unsigned int idx;

2065

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2066

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

2067

v_U32_t value;

2068

char valueStr[CFG_VALUE_MAX_LEN];

2069

char configStr[CFG_ENTRY_MAX_LEN];

2070

char *fmt;

2071

void *pField;

2072

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2077

*pCur = '\0';

2078

2079

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

2080

{

2081

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

2082

2083

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

2084

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2085

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2086

{

2087

value = 0;

2088

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

2089

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

2102

}

2103

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2104

{

2105

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

2106

}

2107

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2108

{

2109

pMacAddr = (v_MACADDR_t *) pField;

2110

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2111

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

2122

}

2123

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2128

"*" : "");

2129

2130

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

2131

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

2132

#ifdef RETURN_IN_BUFFER

2133

if (curlen <= buflen)

2134

{

2135

// copy string + '\0'

2136

memcpy(pCur, configStr, curlen+1);

2137

2138

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2145

return VOS_STATUS_E_RESOURCES;

2146

}

2147

#else

2148

printk(KERN_CRIT "%s", configStr);

2149

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2154

// notify application that output is in system log

2155

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

2156

#endif // RETURN_IN_BUFFER

2157

2158

return VOS_STATUS_SUCCESS;

2159

}

2160

2161

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

2162

char *name, char** value)

2163

{

2164

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2165

unsigned long i;

2166

2167

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

2168

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

2169

*value = iniTable[i].value;

2170

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

2171

WLAN_INI_FILE, name, *value);

2172

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2180

{

2181

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

2182

return c-'0';

2183

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

2184

return c-'a'+10;

2185

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)

2193

{

2194

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2195

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2196

unsigned int idx;

2197

void *pField;

2198

char *value_str = NULL;

2199

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2204

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2205

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

v_U32_t cbOutString;

int i;

// sanity test

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2211

{

2212

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]

2213

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2214

}

2215

2216

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

2217

{

2218

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

2219

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

2220

2221

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

2222

2223

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

2224

{

2225

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

2226

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2227

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2228

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2233

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2234

{

2235

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

2236

// If not, use the default value.

2237

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

2238

value = simple_strtoul(value_str, NULL, 10);

2239

}

2240

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

2241

value = simple_strtoul(value_str, NULL, 16);

2242

}

2243

else {

2244

value = pRegEntry->VarDefault;

2245

}

2246

2247

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

2248

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2249

{

2250

if ( value > pRegEntry->VarMax )

2251

{

2252

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2253

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

Jeff Johnson

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

[diff] [blame]

2254

value = pRegEntry->VarMax;

2255

}

2256

2257

if ( value < pRegEntry->VarMin )

2258

{

2259

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2260

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

Jeff Johnson

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

[diff] [blame]

2261

value = pRegEntry->VarMin;

2262

}

2263

}

2264

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

2265

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2266

{

2267

if ( value > pRegEntry->VarMax )

2268

{

2269

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]

2270

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

Jeff Johnson

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

[diff] [blame]

2271

value = pRegEntry->VarDefault;

2272

}

2273

2274

if ( value < pRegEntry->VarMin )

2275

{

2276

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]

2277

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

Jeff Johnson

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

[diff] [blame]

2278

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2283

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

2284

}

2285

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2286

{

2287

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

2288

// If not, use the default value.

2289

if (VOS_STATUS_SUCCESS == match_status)

2290

{

2291

svalue = simple_strtol(value_str, NULL, 10);

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2296

}

2297

2298

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

2299

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2300

{

2301

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

2302

{

2303

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2304

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

Jeff Johnson

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

[diff] [blame]

2305

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

2306

svalue = (v_S31_t)pRegEntry->VarMax;

2307

}

2308

2309

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

2310

{

2311

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2312

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

Jeff Johnson

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

[diff] [blame]

2313

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

2314

svalue = (v_S31_t)pRegEntry->VarMin;

2315

}

2316

}

2317

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

2318

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2319

{

2320

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

2321

{

2322

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

2323

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2324

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2325

(int)pRegEntry->VarMax,

2326

(int)pRegEntry->VarDefault );

2327

svalue = (v_S31_t)pRegEntry->VarDefault;

2328

}

2329

2330

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

2331

{

2332

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

2333

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2334

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2335

(int)pRegEntry->VarMin,

2336

(int)pRegEntry->VarDefault);

2337

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2342

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

2343

}

2344

// Handle string parameters

2345

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2346

{

2347

#ifdef WLAN_CFG_DEBUG

2348

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

2349

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

2350

#endif

2351

2352

if ( match_status == VOS_STATUS_SUCCESS)

2353

{

2354

len_value_str = strlen(value_str);

2355

2356

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

2357

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]

2358

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

Jeff Johnson

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

[diff] [blame]

2359

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

2360

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

2361

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

}

else

{

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

2366

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

}

}

else

{

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

2372

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

2373

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

2374

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

2375

}

2376

}

2377

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2378

{

2379

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2380

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2381

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

Jeff Johnson

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

[diff] [blame]

2382

continue;

2383

}

2384

candidate = (char*)pRegEntry->VarDefault;

2385

if ( match_status == VOS_STATUS_SUCCESS) {

2386

len_value_str = strlen(value_str);

2387

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

2388

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]

2389

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

Jeff Johnson

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

[diff] [blame]

2390

}

2391

else

2392

candidate = value_str;

2393

}

2394

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

2395

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

2396

{

2397

((char*)pField)[i] =

2398

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

}

}

else

{

hddLog(LOGE, "%s: Unknown param type for name[%s] in registry table\n",

Madan Mohan Koyyalamudi

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

[diff] [blame]

2404

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2405

}

2406

2407

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

2408

if( (match_status == VOS_STATUS_SUCCESS) &&

2409

(idx < MAX_CFG_INI_ITEMS) )

2410

{

2411

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

}

}

print_hdd_cfg(pHddCtx);

2416

2417

return( ret_status );

2418

}

2419

2420

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2425

return eCSR_DOT11_MODE_abg;

2426

case (eHDD_DOT11_MODE_11b):

2427

return eCSR_DOT11_MODE_11b;

2428

case (eHDD_DOT11_MODE_11g):

2429

return eCSR_DOT11_MODE_11g;

2430

default:

2431

case (eHDD_DOT11_MODE_11n):

2432

return eCSR_DOT11_MODE_11n;

2433

case (eHDD_DOT11_MODE_11g_ONLY):

2434

return eCSR_DOT11_MODE_11g_ONLY;

2435

case (eHDD_DOT11_MODE_11n_ONLY):

2436

return eCSR_DOT11_MODE_11n_ONLY;

2437

case (eHDD_DOT11_MODE_11b_ONLY):

2438

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2439

#ifdef WLAN_FEATURE_11AC

2440

case (eHDD_DOT11_MODE_11ac_ONLY):

2441

return eCSR_DOT11_MODE_11ac_ONLY;

2442

case (eHDD_DOT11_MODE_11ac):

2443

return eCSR_DOT11_MODE_11ac;

2444

#endif

Jeff Johnson

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

[diff] [blame]

2445

case (eHDD_DOT11_MODE_AUTO):

2446

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2452

{

2453

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2454

tSmeBtcConfig btcParams;

2455

2456

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2457

2458

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2459

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2460

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2461

Jeff Johnson

32d95a3

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

[diff] [blame]

2462

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2463

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2464

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2465

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2466

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2467

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2468

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2469

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2470

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2471

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2472

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2473

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2474

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2475

Jeff Johnson

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

[diff] [blame]

2476

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2477

}

2478

2479

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

2480

{

2481

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2482

2483

tPmcBmpsConfigParams bmpsParams;

2484

2485

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

2486

2487

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

2488

{

2489

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

2490

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2491

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2492

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2493

}

2494

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

2495

{

2496

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

2497

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2498

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2499

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2500

}

2501

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

2502

{

2503

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

2504

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2505

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2506

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2507

}

2508

2509

if (pConfig->fIsImpsEnabled)

2510

{

2511

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2516

}

2517

2518

if (pConfig->fIsBmpsEnabled)

2519

{

2520

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2525

}

2526

2527

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2528

2529

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

2530

{

2531

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

2532

}

2533

2534

if(pConfig->fIsAutoBmpsTimerEnabled)

2535

{

2536

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2542

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 )

2547

{

2548

return VOS_STATUS_E_INVAL;

}

*len = 0;

#ifdef VERSION_USING_STRPBRK

2553

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

2554

{

2555

int val;

2556

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

2557

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

2558

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

2559

{

2560

intArray[*len] = (tANI_U8) val;

2561

*len += 1;

2562

}

2563

s = strpbrk( s, "," );

if( s )

s++;

}

#else

while( (*s != '\0') && (*len < intArrayMaxLen) )

{

unsigned long val;

val = simple_strtoul( s, &s, 10 );

2573

if( val )

2574

{

2575

intArray[*len] = (tANI_U8) val;

*len += 1;

}

if( *s )

s++;

}

#endif

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2590

{

2591

v_BOOL_t fStatus = TRUE;

2592

2593

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2594

2595

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2596

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

2597

{

2598

fStatus = FALSE;

2599

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

2600

}

2601

2602

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

2603

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2604

{

2605

fStatus = FALSE;

2606

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

2607

}

2608

2609

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

2610

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2611

{

2612

fStatus = FALSE;

2613

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

2614

}

2615

2616

if ( 0 != pConfig->Cfg1Id )

2617

{

2618

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

2619

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2620

{

2621

fStatus = FALSE;

2622

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

}

}

if ( 0 != pConfig->Cfg2Id )

2628

{

2629

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

2630

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2631

{

2632

fStatus = FALSE;

2633

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

}

}

if ( 0 != pConfig->Cfg3Id )

2638

{

2639

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

2640

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2641

{

2642

fStatus = FALSE;

2643

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

}

}

if ( 0 != pConfig->Cfg4Id )

2648

{

2649

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

2650

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2651

{

2652

fStatus = FALSE;

2653

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

}

}

if ( 0 != pConfig->Cfg5Id )

2658

{

2659

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

2660

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2661

{

2662

fStatus = FALSE;

2663

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

}

}

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

2668

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2669

{

2670

fStatus = FALSE;

2671

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

2672

}

2673

2674

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

2675

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2676

{

2677

fStatus = FALSE;

2678

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

2679

}

2680

2681

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2682

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

2683

{

2684

fStatus = FALSE;

2685

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

2686

}

2687

2688

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

2689

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2690

{

2691

fStatus = FALSE;

2692

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

2693

}

2694

2695

if (pConfig->fIsAutoIbssBssid)

2696

{

2697

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

2698

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

2699

{

2700

fStatus = FALSE;

2701

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

}

}

else

{

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

2707

{

2708

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2709

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

2710

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

2711

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

2712

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

2713

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

2714

{

2715

fStatus = FALSE;

2716

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

}

}

else

{

fStatus = FALSE;

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

}

}

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

2727

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2728

{

2729

fStatus = FALSE;

2730

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

2731

}

2732

2733

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

2734

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2735

{

2736

fStatus = FALSE;

2737

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

2738

}

2739

2740

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

2741

{

2742

fStatus = FALSE;

2743

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

2744

}

2745

2746

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

2747

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2748

{

2749

fStatus = FALSE;

2750

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

2751

}

2752

2753

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

2754

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2755

{

2756

fStatus = FALSE;

2757

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

2758

}

2759

Jeff Johnson

04dd8a8

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

[diff] [blame]

2760

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

2761

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_FT_RSSI_FILTER_PERIOD, pConfig->FTRssiFilterPeriod,

2762

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2763

{

2764

fStatus = FALSE;

2765

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

}

#endif

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

2770

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2771

{

2772

fStatus = FALSE;

2773

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

2774

}

2775

2776

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

2777

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2778

{

2779

fStatus = FALSE;

2780

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

2781

}

2782

2783

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

2784

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2785

{

2786

fStatus = FALSE;

2787

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

2788

}

2789

2790

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

2791

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2792

{

2793

fStatus = FALSE;

2794

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

2795

}

2796

2797

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

2798

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2799

{

2800

fStatus = FALSE;

2801

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

2802

}

2803

2804

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

2805

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2806

{

2807

fStatus = FALSE;

2808

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

2809

}

2810

2811

#ifdef WLAN_SOFTAP_FEATURE

2812

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

2813

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2814

{

2815

fStatus = FALSE;

2816

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

2817

}

2818

2819

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

2820

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2821

{

2822

fStatus = FALSE;

2823

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

2824

}

2825

Jeff Johnson

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

[diff] [blame]

2826

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

2827

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2828

{

2829

fStatus = FALSE;

2830

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

2831

}

2832

2833

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

2834

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2835

{

2836

fStatus = FALSE;

2837

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

2842

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

2843

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2844

{

2845

fStatus = FALSE;

2846

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

2847

}

2848

2849

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

2850

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2851

{

2852

fStatus = FALSE;

2853

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

2854

}

2855

2856

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

2857

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2858

{

2859

fStatus = FALSE;

2860

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

2861

}

2862

2863

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

2864

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2865

#endif

2866

2867

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

2868

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2869

{

2870

fStatus = FALSE;

2871

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

2872

}

2873

2874

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

2875

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2876

{

2877

fStatus = FALSE;

2878

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

2879

}

2880

2881

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

2882

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2883

{

2884

fStatus = FALSE;

2885

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

2886

}

2887

2888

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

2889

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2890

{

2891

fStatus = FALSE;

2892

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

2893

}

2894

2895

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

2896

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2897

{

2898

fStatus = FALSE;

2899

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

2900

}

2901

2902

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

2903

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2904

{

2905

fStatus = FALSE;

2906

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

2907

}

2908

2909

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

2910

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2911

{

2912

fStatus = FALSE;

2913

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

2914

}

2915

2916

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

2917

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2918

{

2919

fStatus = FALSE;

2920

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

2921

}

2922

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

2923

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2924

{

2925

fStatus = FALSE;

2926

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

2927

}

2928

2929

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

2930

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2931

{

2932

fStatus = FALSE;

2933

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

2934

}

2935

2936

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

2937

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2938

{

2939

fStatus = FALSE;

2940

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

2941

}

2942

#ifdef FEATURE_WLAN_INTEGRATED_SOC

2943

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

2944

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

2945

{

2946

fStatus = FALSE;

2947

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

2948

}

2949

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

2950

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

2951

{

2952

fStatus = FALSE;

2953

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

2954

}

2955

2956

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

2957

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

2958

{

2959

fStatus = FALSE;

2960

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

2961

}

2962

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

2963

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

2964

{

2965

fStatus = FALSE;

2966

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

}

#endif

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

2971

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2972

{

2973

fStatus = FALSE;

2974

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

2975

}

2976

2977

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

2978

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

2979

==eHAL_STATUS_FAILURE)

2980

{

2981

fStatus = FALSE;

2982

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

2983

}

2984

2985

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

2986

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

2987

==eHAL_STATUS_FAILURE)

2988

{

2989

fStatus = FALSE;

2990

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

2991

}

2992

2993

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

2994

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

2995

{

2996

fStatus = FALSE;

2997

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

2998

}

2999

Jeff Johnson

d13512a

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

[diff] [blame]

3000

3001

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

3002

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3003

{

3004

fStatus = FALSE;

3005

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

3006

}

3007

Jeff Johnson

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

[diff] [blame]

3008

#ifdef WLAN_FEATURE_11AC

3009

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

3010

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

3011

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

3012

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

3013

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3014

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3020

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

3021

3022

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3023

temp, NULL, eANI_BOOLEAN_FALSE)

3024

==eHAL_STATUS_FAILURE)

3025

{

3026

fStatus = FALSE;

3027

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

3028

}

3029

3030

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

3031

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

3032

3033

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3034

temp, NULL, eANI_BOOLEAN_FALSE)

3035

==eHAL_STATUS_FAILURE)

3036

{

3037

fStatus = FALSE;

3038

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

3039

}

3040

3041

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

3042

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

3043

3044

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3045

temp, NULL, eANI_BOOLEAN_FALSE)

3046

==eHAL_STATUS_FAILURE)

3047

{

3048

fStatus = FALSE;

3049

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

}

}

}

#endif

Madan Mohan Koyyalamudi

dd11eaf

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

[diff] [blame]

3055

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

3056

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3057

{

3058

fStatus = FALSE;

3059

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

3060

}

3061

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3067

3068

\brief hdd_init_set_sme_config() -

3069

3070

This function initializes the sme configuration parameters

3071

3072

\param - pHddCtx - Pointer to the HDD Adapter.

3073

3074

\return - 0 for success, non zero for failure

3075

3076

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

3077

3078

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3079

{

3080

VOS_STATUS status = VOS_STATUS_SUCCESS;

3081

eHalStatus halStatus;

3082

tSmeConfigParams smeConfig;

3083

3084

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3085

3086

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3087

3088

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3089

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

3090

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

3091

3092

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3093

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3094

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

Jeff Johnson

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

[diff] [blame]

3095

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3096

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3097

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3098

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3099

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3100

3101

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

3102

3103

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3104

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3105

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3106

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3107

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3108

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3109

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3110

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3111

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3112

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3113

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3114

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3115

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3116

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3117

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3118

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3119

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3120

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3121

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3122

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3123

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3124

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3125

#ifdef WLAN_AP_STA_CONCURRENCY

3126

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3127

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3128

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3129

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3130

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

3131

#endif

Jeff Johnson

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

[diff] [blame]

3132

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3133

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3134

3135

#if defined WLAN_FEATURE_VOWIFI

3136

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3137

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3138

#endif

3139

//Remaining config params not obtained from registry

3140

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3141

#ifdef WLAN_FEATURE_11AC

3142

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3143

#endif

Jeff Johnson

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

[diff] [blame]

3144

smeConfig.csrConfig.AdHocChannel5G = 44;

3145

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3146

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3147

smeConfig.csrConfig.Is11hSupportEnabled = 1;

Jeff Johnson

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

[diff] [blame]

3148

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

3149

smeConfig.csrConfig.cbChoice = 0;

3150

smeConfig.csrConfig.bgScanInterval = 0;

3151

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3152

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3153

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3154

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame^]

3155

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Jeff Johnson

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

[diff] [blame]

3156

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3157

Jeff Johnson

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

[diff] [blame]

3158

//FIXME 11d config is hardcoded

3159

#ifdef WLAN_SOFTAP_FEATURE

3160

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3161

#endif

3162

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

3163

3164

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

3165

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

3166

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

3167

3168

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3173

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

3174

3175

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

3176

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

3177

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3178

}

3179

#endif

3180

hdd_set_power_save_config(pHddCtx, &smeConfig);

3181

hdd_set_btc_config(pHddCtx);

3182

3183

#ifdef WLAN_FEATURE_VOWIFI_11R

3184

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

3185

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3186

#ifdef FEATURE_WLAN_LFR

3187

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

3188

#endif

Jeff Johnson

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

[diff] [blame]

3189

#ifdef FEATURE_WLAN_CCX

3190

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

3191

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3192

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

3193

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3194

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3195

#endif

3196

3197

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3198

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

3199

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

3200

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

3201

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

3202

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

3203

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

3204

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

3205

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3206

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3207

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3208

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3209

#endif

3210

3211

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3212

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3213

3214

//Enable/Disable MCC

3215

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3216

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3217

3218

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

3219

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3220

{

3221

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3230

3231

\brief hdd_execute_config_command() -

3232

3233

This function executes an arbitrary configuration set command

3234

3235

\param - pHddCtx - Pointer to the HDD Adapter.

3236

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

3237

3238

3239

\return - 0 for success, non zero for failure

3240

3241

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

3242

3243

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3244

{

3245

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

3246

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;

unsigned int idx;

unsigned int i;

VOS_STATUS vstatus;

// assume failure until proven otherwise

3260

vstatus = VOS_STATUS_E_FAILURE;

3261

3262

// clone the command so that we can manipulate it

3263

clone = kstrdup(command, GFP_ATOMIC);

3264

if (NULL == clone)

3265

{

3266

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3267

__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

3272

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

3273

pCmd = clone;

3274

3275

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

3281

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3286

name = pCmd;

3287

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]

3295

__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

3305

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3306

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3311

if ('\0' == *value_str)

3312

{

3313

// did not find a value

3314

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3315

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3320

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

3321

{

3322

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

{

// found a match

break;

}

}

if (tableSize == idx)

3329

{

3330

// did not match the name

3331

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3332

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3337

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

3338

{

3339

// does not support dynamic configuration

3340

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3341

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

3346

3347

switch (pRegEntry->RegType)

3348

{

3349

case WLAN_PARAM_Integer:

3350

value = simple_strtoul(value_str, NULL, 10);

3351

if (value < pRegEntry->VarMin)

3352

{

3353

// out of range

3354

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3355

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3356

goto done;

3357

}

3358

if (value > pRegEntry->VarMax)

3359

{

3360

// out of range

3361

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3362

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3363

goto done;

3364

}

3365

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

3366

break;

3367

3368

case WLAN_PARAM_HexInteger:

3369

value = simple_strtoul(value_str, NULL, 16);

3370

if (value < pRegEntry->VarMin)

3371

{

3372

// out of range

3373

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3374

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3375

goto done;

3376

}

3377

if (value > pRegEntry->VarMax)

3378

{

3379

// out of range

3380

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3381

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3382

goto done;

3383

}

3384

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

3385

break;

3386

3387

case WLAN_PARAM_SignedInteger:

3388

svalue = simple_strtol(value_str, NULL, 10);

3389

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

3390

{

3391

// out of range

3392

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3393

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

Jeff Johnson

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

[diff] [blame]

3394

goto done;

3395

}

3396

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

3397

{

3398

// out of range

3399

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3400

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

Jeff Johnson

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

[diff] [blame]

3401

goto done;

3402

}

3403

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

3404

break;

3405

3406

case WLAN_PARAM_String:

3407

len_value_str = strlen(value_str);

3408

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

{

// too big

hddLog(LOGE,

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

3413

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3414

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3415

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

3416

goto done;

3417

}

3418

// copy string plus NUL

3419

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

3420

break;

3421

3422

case WLAN_PARAM_MacAddr:

3423

len_value_str = strlen(value_str);

3424

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3429

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3430

__func__, value_str,

Jeff Johnson