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

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

[diff] [blame]

2110

#ifdef WLAN_FEATURE_11AC

2111

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

2112

#endif

2113

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

2114

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

2115

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]

2116

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

Pratik Bhalgat

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

[diff] [blame]

2117

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

2118

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

Jeff Johnson

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

[diff] [blame]

}

#define CFG_VALUE_MAX_LEN 256

2123

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2124

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

2125

{

2126

unsigned int idx;

2127

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2128

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

2129

v_U32_t value;

2130

char valueStr[CFG_VALUE_MAX_LEN];

2131

char configStr[CFG_ENTRY_MAX_LEN];

2132

char *fmt;

2133

void *pField;

2134

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2139

*pCur = '\0';

2140

2141

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

2142

{

2143

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

2144

2145

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

2146

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2147

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2148

{

2149

value = 0;

2150

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

2151

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

2164

}

2165

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2166

{

2167

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

2168

}

2169

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2170

{

2171

pMacAddr = (v_MACADDR_t *) pField;

2172

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2173

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

2184

}

2185

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2190

"*" : "");

2191

2192

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

2193

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

2194

#ifdef RETURN_IN_BUFFER

2195

if (curlen <= buflen)

2196

{

2197

// copy string + '\0'

2198

memcpy(pCur, configStr, curlen+1);

2199

2200

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2207

return VOS_STATUS_E_RESOURCES;

2208

}

2209

#else

2210

printk(KERN_CRIT "%s", configStr);

2211

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2216

// notify application that output is in system log

2217

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

2218

#endif // RETURN_IN_BUFFER

2219

2220

return VOS_STATUS_SUCCESS;

2221

}

2222

2223

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

2224

char *name, char** value)

2225

{

2226

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2227

unsigned long i;

2228

2229

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

2230

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

2231

*value = iniTable[i].value;

2232

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

2233

WLAN_INI_FILE, name, *value);

2234

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2242

{

2243

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

2244

return c-'0';

2245

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

2246

return c-'a'+10;

2247

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)

2255

{

2256

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2257

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2258

unsigned int idx;

2259

void *pField;

2260

char *value_str = NULL;

2261

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2266

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2267

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

2268

v_U32_t cbOutString;

2269

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2270

int rv;

Jeff Johnson

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

[diff] [blame]

2271

2272

// sanity test

2273

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2274

{

2275

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]

2276

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2277

}

2278

2279

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

2280

{

2281

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

2282

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

2283

2284

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

2285

2286

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

2287

{

2288

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

2289

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2290

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2291

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2296

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2297

{

2298

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

2299

// If not, use the default value.

2300

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2301

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

2302

if (rv < 0) {

2303

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

2304

__func__, pRegEntry->RegName);

2305

value = pRegEntry->VarDefault;

2306

}

Jeff Johnson

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

[diff] [blame]

2307

}

2308

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2309

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

2310

if (rv < 0) {

2311

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

2312

__func__, pRegEntry->RegName);

2313

value = pRegEntry->VarDefault;

2314

}

Jeff Johnson

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

[diff] [blame]

2315

}

2316

else {

2317

value = pRegEntry->VarDefault;

2318

}

2319

2320

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

2321

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2322

{

2323

if ( value > pRegEntry->VarMax )

2324

{

2325

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2326

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

Jeff Johnson

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

[diff] [blame]

2327

value = pRegEntry->VarMax;

2328

}

2329

2330

if ( value < pRegEntry->VarMin )

2331

{

2332

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2333

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

Jeff Johnson

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

[diff] [blame]

2334

value = pRegEntry->VarMin;

2335

}

2336

}

2337

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

2338

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2339

{

2340

if ( value > pRegEntry->VarMax )

2341

{

2342

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]

2343

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

Jeff Johnson

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

[diff] [blame]

2344

value = pRegEntry->VarDefault;

2345

}

2346

2347

if ( value < pRegEntry->VarMin )

2348

{

2349

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]

2350

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

Jeff Johnson

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

[diff] [blame]

2351

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2356

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

2357

}

2358

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2359

{

2360

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

2361

// If not, use the default value.

2362

if (VOS_STATUS_SUCCESS == match_status)

2363

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2364

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

2365

if (rv < 0) {

2366

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

2367

__func__, pRegEntry->RegName);

2368

svalue = (v_S31_t)pRegEntry->VarDefault;

2369

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2374

}

2375

2376

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

2377

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2378

{

2379

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

2380

{

2381

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2382

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

Jeff Johnson

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

[diff] [blame]

2383

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

2384

svalue = (v_S31_t)pRegEntry->VarMax;

2385

}

2386

2387

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

2388

{

2389

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2390

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

Jeff Johnson

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

[diff] [blame]

2391

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

2392

svalue = (v_S31_t)pRegEntry->VarMin;

2393

}

2394

}

2395

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

2396

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2397

{

2398

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

2399

{

2400

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

2401

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2402

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2403

(int)pRegEntry->VarMax,

2404

(int)pRegEntry->VarDefault );

2405

svalue = (v_S31_t)pRegEntry->VarDefault;

2406

}

2407

2408

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

2409

{

2410

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

2411

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2412

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2413

(int)pRegEntry->VarMin,

2414

(int)pRegEntry->VarDefault);

2415

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2420

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

2421

}

2422

// Handle string parameters

2423

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2424

{

2425

#ifdef WLAN_CFG_DEBUG

2426

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

2427

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

2428

#endif

2429

2430

if ( match_status == VOS_STATUS_SUCCESS)

2431

{

2432

len_value_str = strlen(value_str);

2433

2434

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

2435

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]

2436

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

Jeff Johnson

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

[diff] [blame]

2437

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

2438

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

2439

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

}

else

{

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

2444

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

}

}

else

{

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

2450

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

2451

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

2452

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

2453

}

2454

}

2455

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2456

{

2457

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2458

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2459

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

Jeff Johnson

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

[diff] [blame]

2460

continue;

2461

}

2462

candidate = (char*)pRegEntry->VarDefault;

2463

if ( match_status == VOS_STATUS_SUCCESS) {

2464

len_value_str = strlen(value_str);

2465

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

2466

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]

2467

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

Jeff Johnson

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

[diff] [blame]

2468

}

2469

else

2470

candidate = value_str;

2471

}

2472

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

2473

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

2474

{

2475

((char*)pField)[i] =

2476

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

2482

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2483

}

2484

2485

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

2486

if( (match_status == VOS_STATUS_SUCCESS) &&

2487

(idx < MAX_CFG_INI_ITEMS) )

2488

{

2489

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

}

}

print_hdd_cfg(pHddCtx);

2494

2495

return( ret_status );

2496

}

2497

2498

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2503

return eCSR_DOT11_MODE_abg;

2504

case (eHDD_DOT11_MODE_11b):

2505

return eCSR_DOT11_MODE_11b;

2506

case (eHDD_DOT11_MODE_11g):

2507

return eCSR_DOT11_MODE_11g;

2508

default:

2509

case (eHDD_DOT11_MODE_11n):

2510

return eCSR_DOT11_MODE_11n;

2511

case (eHDD_DOT11_MODE_11g_ONLY):

2512

return eCSR_DOT11_MODE_11g_ONLY;

2513

case (eHDD_DOT11_MODE_11n_ONLY):

2514

return eCSR_DOT11_MODE_11n_ONLY;

2515

case (eHDD_DOT11_MODE_11b_ONLY):

2516

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2517

#ifdef WLAN_FEATURE_11AC

2518

case (eHDD_DOT11_MODE_11ac_ONLY):

2519

return eCSR_DOT11_MODE_11ac_ONLY;

2520

case (eHDD_DOT11_MODE_11ac):

2521

return eCSR_DOT11_MODE_11ac;

2522

#endif

Jeff Johnson

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

[diff] [blame]

2523

case (eHDD_DOT11_MODE_AUTO):

2524

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2530

{

2531

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2532

tSmeBtcConfig btcParams;

2533

2534

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2535

2536

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2537

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2538

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2539

Jeff Johnson

32d95a3

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

[diff] [blame]

2540

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2541

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2542

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2543

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2544

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2545

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2546

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2547

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2548

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2549

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2550

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2551

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2552

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2553

Jeff Johnson

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

[diff] [blame]

2554

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2555

}

2556

2557

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

2558

{

2559

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2560

2561

tPmcBmpsConfigParams bmpsParams;

2562

2563

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

2564

2565

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

2566

{

2567

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

2568

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2569

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2570

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2571

}

2572

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

2573

{

2574

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

2575

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2576

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2577

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2578

}

2579

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

2580

{

2581

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

2582

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2583

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2584

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2585

}

2586

2587

if (pConfig->fIsImpsEnabled)

2588

{

2589

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2594

}

2595

2596

if (pConfig->fIsBmpsEnabled)

2597

{

2598

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2603

}

2604

2605

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2606

2607

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

2608

{

2609

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

2610

}

2611

2612

if(pConfig->fIsAutoBmpsTimerEnabled)

2613

{

2614

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2620

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 )

2625

{

2626

return VOS_STATUS_E_INVAL;

}

*len = 0;

#ifdef VERSION_USING_STRPBRK

2631

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

2632

{

2633

int val;

2634

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

2635

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

2636

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

2637

{

2638

intArray[*len] = (tANI_U8) val;

2639

*len += 1;

2640

}

2641

s = strpbrk( s, "," );

if( s )

s++;

}

#else

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

2647

{

2648

unsigned long val;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2649

int rv;

Jeff Johnson

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

[diff] [blame]

2650

Madan Mohan Koyyalamudi

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

[diff] [blame]

2651

rv = kstrtoul( s, 10, &val );

2652

if (rv < 0)

2653

return VOS_STATUS_E_INVAL;

Jeff Johnson

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

[diff] [blame]

2654

if( val )

2655

{

2656

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 )

2671

{

2672

v_BOOL_t fStatus = TRUE;

2673

2674

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2675

tSirMacHTCapabilityInfo htCapInfo;

2676

Jeff Johnson

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

[diff] [blame]

2677

2678

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2679

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

2680

{

2681

fStatus = FALSE;

2682

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

2683

}

2684

2685

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

2686

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2687

{

2688

fStatus = FALSE;

2689

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

2690

}

2691

2692

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

2693

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2694

{

2695

fStatus = FALSE;

2696

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

2697

}

2698

2699

if ( 0 != pConfig->Cfg1Id )

2700

{

2701

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

2702

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2703

{

2704

fStatus = FALSE;

2705

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

}

}

if ( 0 != pConfig->Cfg2Id )

2711

{

2712

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

2713

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2714

{

2715

fStatus = FALSE;

2716

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

}

}

if ( 0 != pConfig->Cfg3Id )

2721

{

2722

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

2723

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2724

{

2725

fStatus = FALSE;

2726

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

}

}

if ( 0 != pConfig->Cfg4Id )

2731

{

2732

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

2733

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2734

{

2735

fStatus = FALSE;

2736

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

}

}

if ( 0 != pConfig->Cfg5Id )

2741

{

2742

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

2743

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2744

{

2745

fStatus = FALSE;

2746

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

}

}

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

2751

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2752

{

2753

fStatus = FALSE;

2754

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

2755

}

2756

2757

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

2758

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2759

{

2760

fStatus = FALSE;

2761

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

2762

}

2763

2764

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2765

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

2766

{

2767

fStatus = FALSE;

2768

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

2769

}

2770

2771

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

2772

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2773

{

2774

fStatus = FALSE;

2775

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

2776

}

2777

2778

if (pConfig->fIsAutoIbssBssid)

2779

{

2780

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

2781

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

2782

{

2783

fStatus = FALSE;

2784

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

}

}

else

{

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

2790

{

2791

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2792

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

2793

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

2794

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

2795

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

2796

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

2797

{

2798

fStatus = FALSE;

2799

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,

2810

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2811

{

2812

fStatus = FALSE;

2813

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

2814

}

2815

2816

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

2817

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2818

{

2819

fStatus = FALSE;

2820

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

2821

}

2822

2823

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

2824

{

2825

fStatus = FALSE;

2826

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

2827

}

2828

2829

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

2830

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2831

{

2832

fStatus = FALSE;

2833

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

2834

}

2835

2836

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

2837

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2838

{

2839

fStatus = FALSE;

2840

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

2841

}

2842

Jeff Johnson

04dd8a8

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

[diff] [blame]

2843

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

2844

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

2845

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2846

{

2847

fStatus = FALSE;

2848

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,

2853

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2854

{

2855

fStatus = FALSE;

2856

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

2857

}

2858

2859

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

2860

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2861

{

2862

fStatus = FALSE;

2863

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

2864

}

2865

2866

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

2867

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2868

{

2869

fStatus = FALSE;

2870

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

2871

}

2872

2873

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

2874

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2875

{

2876

fStatus = FALSE;

2877

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

2878

}

2879

2880

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

2881

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2882

{

2883

fStatus = FALSE;

2884

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

2885

}

2886

2887

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

2888

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2889

{

2890

fStatus = FALSE;

2891

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

2892

}

2893

2894

#ifdef WLAN_SOFTAP_FEATURE

2895

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

2896

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2897

{

2898

fStatus = FALSE;

2899

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

2900

}

2901

2902

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

2903

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2904

{

2905

fStatus = FALSE;

2906

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

2907

}

2908

Jeff Johnson

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

[diff] [blame]

2909

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

2910

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2911

{

2912

fStatus = FALSE;

2913

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

2914

}

2915

2916

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

2917

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2918

{

2919

fStatus = FALSE;

2920

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

2925

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

2926

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2927

{

2928

fStatus = FALSE;

2929

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

2930

}

2931

2932

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

2933

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2934

{

2935

fStatus = FALSE;

2936

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

2937

}

2938

2939

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

2940

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2941

{

2942

fStatus = FALSE;

2943

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

2944

}

2945

2946

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

2947

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2948

#endif

2949

2950

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

2951

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2952

{

2953

fStatus = FALSE;

2954

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

2955

}

2956

2957

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

2958

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2959

{

2960

fStatus = FALSE;

2961

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

2962

}

2963

2964

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

2965

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2966

{

2967

fStatus = FALSE;

2968

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

2969

}

2970

2971

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

2972

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2973

{

2974

fStatus = FALSE;

2975

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

2976

}

2977

2978

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

2979

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2980

{

2981

fStatus = FALSE;

2982

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

2983

}

2984

2985

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

2986

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2987

{

2988

fStatus = FALSE;

2989

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

2990

}

2991

2992

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

2993

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2994

{

2995

fStatus = FALSE;

2996

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

2997

}

2998

2999

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

3000

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3001

{

3002

fStatus = FALSE;

3003

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

3004

}

3005

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

3006

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3007

{

3008

fStatus = FALSE;

3009

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

3010

}

3011

3012

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

3013

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3014

{

3015

fStatus = FALSE;

3016

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

3017

}

3018

3019

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

3020

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3021

{

3022

fStatus = FALSE;

3023

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

3024

}

3025

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3026

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

3027

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3028

{

3029

fStatus = FALSE;

3030

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

3031

}

3032

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

3033

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3034

{

3035

fStatus = FALSE;

3036

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

3037

}

3038

3039

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

3040

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3041

{

3042

fStatus = FALSE;

3043

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

3044

}

3045

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

3046

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3047

{

3048

fStatus = FALSE;

3049

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,

3054

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3055

{

3056

fStatus = FALSE;

3057

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

3058

}

3059

3060

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3061

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3062

==eHAL_STATUS_FAILURE)

3063

{

3064

fStatus = FALSE;

3065

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

3066

}

3067

3068

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3069

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3070

==eHAL_STATUS_FAILURE)

3071

{

3072

fStatus = FALSE;

3073

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

3074

}

3075

3076

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3077

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

3078

{

3079

fStatus = FALSE;

3080

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

3081

}

3082

Jeff Johnson

d13512a

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

[diff] [blame]

3083

3084

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

3085

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3086

{

3087

fStatus = FALSE;

3088

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

3089

}

3090

Jeff Johnson

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

[diff] [blame]

3091

#ifdef WLAN_FEATURE_11AC

3092

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

3093

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

3094

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

3095

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

3096

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3097

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3103

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

3104

3105

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3106

temp, NULL, eANI_BOOLEAN_FALSE)

3107

==eHAL_STATUS_FAILURE)

3108

{

3109

fStatus = FALSE;

3110

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

3111

}

3112

3113

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

3114

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

3115

3116

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3117

temp, NULL, eANI_BOOLEAN_FALSE)

3118

==eHAL_STATUS_FAILURE)

3119

{

3120

fStatus = FALSE;

3121

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

3122

}

3123

3124

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

3125

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

3126

3127

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3128

temp, NULL, eANI_BOOLEAN_FALSE)

3129

==eHAL_STATUS_FAILURE)

3130

{

3131

fStatus = FALSE;

3132

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]

3138

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

3139

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3140

{

3141

fStatus = FALSE;

3142

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

3143

}

3144

Pratik Bhalgat

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

[diff] [blame]

3145

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3146

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3147

==eHAL_STATUS_FAILURE)

3148

{

3149

fStatus = FALSE;

3150

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

3151

}

3152

3153

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

3154

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3155

3156

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3157

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

3158

==eHAL_STATUS_FAILURE)

3159

{

3160

fStatus = FALSE;

3161

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

3162

}

3163

3164

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3165

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3166

==eHAL_STATUS_FAILURE)

3167

{

3168

fStatus = FALSE;

3169

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

3170

}

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame^]

3171

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3172

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3173

==eHAL_STATUS_FAILURE)

3174

{

3175

fStatus = FALSE;

3176

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

3177

}

Pratik Bhalgat

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

[diff] [blame]

3178

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3184

3185

\brief hdd_init_set_sme_config() -

3186

3187

This function initializes the sme configuration parameters

3188

3189

\param - pHddCtx - Pointer to the HDD Adapter.

3190

3191

\return - 0 for success, non zero for failure

3192

3193

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

3194

3195

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3196

{

3197

VOS_STATUS status = VOS_STATUS_SUCCESS;

3198

eHalStatus halStatus;

3199

tSmeConfigParams smeConfig;

3200

3201

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3202

3203

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3204

3205

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3206

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

3207

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

3208

3209

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3210

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3211

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

Jeff Johnson

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

[diff] [blame]

3212

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3213

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3214

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3215

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3216

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3217

3218

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

3219

3220

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3221

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3222

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3223

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3224

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3225

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3226

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3227

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3228

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3229

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3230

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3231

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3232

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3233

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3234

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3235

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3236

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3237

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3238

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3239

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3240

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3241

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3242

#ifdef WLAN_AP_STA_CONCURRENCY

3243

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3244

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3245

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3246

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3247

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

3248

#endif

Jeff Johnson

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

[diff] [blame]

3249

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3250

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3251

3252

#if defined WLAN_FEATURE_VOWIFI

3253

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3254

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3255

#endif

3256

//Remaining config params not obtained from registry

3257

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3258

#ifdef WLAN_FEATURE_11AC

3259

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3260

#endif

Jeff Johnson

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

[diff] [blame]

3261

smeConfig.csrConfig.AdHocChannel5G = 44;

3262

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3263

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3264

smeConfig.csrConfig.Is11hSupportEnabled = 1;

Jeff Johnson

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

[diff] [blame]

3265

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

3266

smeConfig.csrConfig.cbChoice = 0;

3267

smeConfig.csrConfig.bgScanInterval = 0;

3268

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3269

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3270

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3271

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3272

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3273

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

3274

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3275

#endif

Jeff Johnson

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

[diff] [blame]

3276

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3277

Jeff Johnson

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

[diff] [blame]

3278

//FIXME 11d config is hardcoded

3279

#ifdef WLAN_SOFTAP_FEATURE

3280

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3281

#endif

3282

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

3283

3284

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

3285

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

3286

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

3287

3288

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3293

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

3294

3295

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

3296

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

3297

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3298

}

3299

#endif

3300

hdd_set_power_save_config(pHddCtx, &smeConfig);

3301

hdd_set_btc_config(pHddCtx);

3302

3303

#ifdef WLAN_FEATURE_VOWIFI_11R

3304

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

3305

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3306

#ifdef FEATURE_WLAN_LFR

3307

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

3308

#endif

Jeff Johnson

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

[diff] [blame]

3309

#ifdef FEATURE_WLAN_CCX

3310

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

3311

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3312

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

3313

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3314

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3315

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3316

#endif

3317

3318

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3319

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

3320

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

3321

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

3322

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

3323

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

3324

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

3325

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

3326

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3327

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3328

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3329

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3330

#endif

3331

3332

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3333

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3334

3335

//Enable/Disable MCC

3336

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3337

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3338

3339

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

3340

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3341

{

3342

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3351

3352

\brief hdd_execute_config_command() -

3353

3354

This function executes an arbitrary configuration set command

3355

3356

\param - pHddCtx - Pointer to the HDD Adapter.

3357

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

3358

3359

3360

\return - 0 for success, non zero for failure

3361

3362

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

3363

3364

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3365

{

3366

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

3367

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;

3376

unsigned int idx;

3377

unsigned int i;

3378

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3379

int rv;

Jeff Johnson

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

[diff] [blame]

3380

3381

// assume failure until proven otherwise

3382

vstatus = VOS_STATUS_E_FAILURE;

3383

3384

// clone the command so that we can manipulate it

3385

clone = kstrdup(command, GFP_ATOMIC);

3386

if (NULL == clone)

3387

{

3388

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3389

__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

3394

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

3395

pCmd = clone;

3396

3397

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

3403

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3408

name = pCmd;

3409

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]

3417

__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

3427

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3428

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3433

if ('\0' == *value_str)

3434

{

3435

// did not find a value

3436

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3437

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3442

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

3443

{

3444

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

{

// found a match

break;

}

}

if (tableSize == idx)

3451

{

3452

// did not match the name

3453

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3454

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3459

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

3460

{

3461

// does not support dynamic configuration

3462

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3463

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

3468

3469

switch (pRegEntry->RegType)

3470

{

3471

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3472

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

3473

if (rv < 0)

3474

goto done;

Jeff Johnson

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

[diff] [blame]

3475

if (value < pRegEntry->VarMin)

3476

{

3477

// out of range

3478

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3479

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3480

goto done;

3481

}

3482

if (value > pRegEntry->VarMax)

3483

{

3484

// out of range

3485

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3486

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3487

goto done;

3488

}

3489

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

3490

break;

3491

3492

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3493

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

3494

if (rv < 0)

3495

goto done;

Jeff Johnson

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

[diff] [blame]

3496

if (value < pRegEntry->VarMin)

3497

{

3498

// out of range

3499

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3500

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3501

goto done;

3502

}

3503

if (value > pRegEntry->VarMax)

3504

{

3505

// out of range

3506

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3507

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3508

goto done;

3509

}

3510

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

3511

break;

3512

3513

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3514

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

3515

if (rv < 0)

3516

goto done;

Jeff Johnson

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

[diff] [blame]

3517

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

3518

{

3519

// out of range

3520

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3521

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

Jeff Johnson

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

[diff] [blame]

3522

goto done;

3523

}

3524

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

3525

{

3526

// out of range

3527

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3528

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

Jeff Johnson

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

[diff] [blame]

3529

goto done;

3530

}

3531

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

3532

break;

3533

3534

case WLAN_PARAM_String:

3535

len_value_str = strlen(value_str);

3536

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

{

// too big

hddLog(LOGE,

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

3541

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3542

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3543

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

3544

goto done;

3545

}

3546

// copy string plus NUL

3547

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

3548

break;

3549

3550

case WLAN_PARAM_MacAddr:

3551

len_value_str = strlen(value_str);

3552

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3557

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3558

__func__, value_str,

Jeff Johnson