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

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

[diff] [blame]

2183

#ifdef WLAN_FEATURE_11AC

2184

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

2185

#endif

2186

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

2187

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

2188

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]

2189

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]

2190

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]

2191

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

2196

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2197

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

2198

{

2199

unsigned int idx;

2200

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2201

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

2202

v_U32_t value;

2203

char valueStr[CFG_VALUE_MAX_LEN];

2204

char configStr[CFG_ENTRY_MAX_LEN];

2205

char *fmt;

2206

void *pField;

2207

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2212

*pCur = '\0';

2213

2214

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

2215

{

2216

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

2217

2218

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

2219

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2220

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2221

{

2222

value = 0;

2223

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

2224

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

2237

}

2238

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2239

{

2240

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

2241

}

2242

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2243

{

2244

pMacAddr = (v_MACADDR_t *) pField;

2245

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2246

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

2257

}

2258

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2263

"*" : "");

2264

2265

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

2266

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

2267

#ifdef RETURN_IN_BUFFER

2268

if (curlen <= buflen)

2269

{

2270

// copy string + '\0'

2271

memcpy(pCur, configStr, curlen+1);

2272

2273

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2280

return VOS_STATUS_E_RESOURCES;

2281

}

2282

#else

2283

printk(KERN_CRIT "%s", configStr);

2284

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2289

// notify application that output is in system log

2290

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

2291

#endif // RETURN_IN_BUFFER

2292

2293

return VOS_STATUS_SUCCESS;

2294

}

2295

2296

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

2297

char *name, char** value)

2298

{

2299

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2300

unsigned long i;

2301

2302

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

2303

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

2304

*value = iniTable[i].value;

2305

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

2306

WLAN_INI_FILE, name, *value);

2307

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2315

{

2316

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

2317

return c-'0';

2318

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

2319

return c-'a'+10;

2320

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)

2328

{

2329

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2330

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2331

unsigned int idx;

2332

void *pField;

2333

char *value_str = NULL;

2334

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2339

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2340

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

2341

v_U32_t cbOutString;

2342

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2343

int rv;

Jeff Johnson

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

[diff] [blame]

2344

2345

// sanity test

2346

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2347

{

2348

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]

2349

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2350

}

2351

2352

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

2353

{

2354

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

2355

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

2356

2357

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

2358

2359

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

2360

{

2361

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

2362

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2363

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2364

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2369

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2370

{

2371

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

2372

// If not, use the default value.

2373

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2374

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

2375

if (rv < 0) {

2376

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

2377

__func__, pRegEntry->RegName);

2378

value = pRegEntry->VarDefault;

2379

}

Jeff Johnson

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

[diff] [blame]

2380

}

2381

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2382

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

2383

if (rv < 0) {

2384

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

2385

__func__, pRegEntry->RegName);

2386

value = pRegEntry->VarDefault;

2387

}

Jeff Johnson

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

[diff] [blame]

2388

}

2389

else {

2390

value = pRegEntry->VarDefault;

2391

}

2392

2393

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

2394

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2395

{

2396

if ( value > pRegEntry->VarMax )

2397

{

2398

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2399

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

Jeff Johnson

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

[diff] [blame]

2400

value = pRegEntry->VarMax;

2401

}

2402

2403

if ( value < pRegEntry->VarMin )

2404

{

2405

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2406

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

Jeff Johnson

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

[diff] [blame]

2407

value = pRegEntry->VarMin;

2408

}

2409

}

2410

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

2411

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2412

{

2413

if ( value > pRegEntry->VarMax )

2414

{

2415

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]

2416

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

Jeff Johnson

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

[diff] [blame]

2417

value = pRegEntry->VarDefault;

2418

}

2419

2420

if ( value < pRegEntry->VarMin )

2421

{

2422

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]

2423

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

Jeff Johnson

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

[diff] [blame]

2424

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2429

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

2430

}

2431

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2432

{

2433

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

2434

// If not, use the default value.

2435

if (VOS_STATUS_SUCCESS == match_status)

2436

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2437

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

2438

if (rv < 0) {

2439

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

2440

__func__, pRegEntry->RegName);

2441

svalue = (v_S31_t)pRegEntry->VarDefault;

2442

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2447

}

2448

2449

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

2450

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2451

{

2452

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

2453

{

2454

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2455

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

Jeff Johnson

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

[diff] [blame]

2456

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

2457

svalue = (v_S31_t)pRegEntry->VarMax;

2458

}

2459

2460

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

2461

{

2462

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2463

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

Jeff Johnson

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

[diff] [blame]

2464

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

2465

svalue = (v_S31_t)pRegEntry->VarMin;

2466

}

2467

}

2468

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

2469

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2470

{

2471

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

2472

{

2473

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

2474

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2475

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2476

(int)pRegEntry->VarMax,

2477

(int)pRegEntry->VarDefault );

2478

svalue = (v_S31_t)pRegEntry->VarDefault;

2479

}

2480

2481

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

2482

{

2483

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

2484

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2485

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2486

(int)pRegEntry->VarMin,

2487

(int)pRegEntry->VarDefault);

2488

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2493

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

2494

}

2495

// Handle string parameters

2496

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2497

{

2498

#ifdef WLAN_CFG_DEBUG

2499

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

2500

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

2501

#endif

2502

2503

if ( match_status == VOS_STATUS_SUCCESS)

2504

{

2505

len_value_str = strlen(value_str);

2506

2507

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

2508

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]

2509

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

Jeff Johnson

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

[diff] [blame]

2510

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

2511

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

2512

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

}

else

{

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

2517

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

}

}

else

{

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

2523

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

2524

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

2525

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

2526

}

2527

}

2528

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2529

{

2530

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2531

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2532

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

Jeff Johnson

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

[diff] [blame]

2533

continue;

2534

}

2535

candidate = (char*)pRegEntry->VarDefault;

2536

if ( match_status == VOS_STATUS_SUCCESS) {

2537

len_value_str = strlen(value_str);

2538

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

2539

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]

2540

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

Jeff Johnson

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

[diff] [blame]

2541

}

2542

else

2543

candidate = value_str;

2544

}

2545

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

2546

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

2547

{

2548

((char*)pField)[i] =

2549

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

2555

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2556

}

2557

2558

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

2559

if( (match_status == VOS_STATUS_SUCCESS) &&

2560

(idx < MAX_CFG_INI_ITEMS) )

2561

{

2562

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

}

}

print_hdd_cfg(pHddCtx);

2567

2568

return( ret_status );

2569

}

2570

2571

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2576

return eCSR_DOT11_MODE_abg;

2577

case (eHDD_DOT11_MODE_11b):

2578

return eCSR_DOT11_MODE_11b;

2579

case (eHDD_DOT11_MODE_11g):

2580

return eCSR_DOT11_MODE_11g;

2581

default:

2582

case (eHDD_DOT11_MODE_11n):

2583

return eCSR_DOT11_MODE_11n;

2584

case (eHDD_DOT11_MODE_11g_ONLY):

2585

return eCSR_DOT11_MODE_11g_ONLY;

2586

case (eHDD_DOT11_MODE_11n_ONLY):

2587

return eCSR_DOT11_MODE_11n_ONLY;

2588

case (eHDD_DOT11_MODE_11b_ONLY):

2589

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2590

#ifdef WLAN_FEATURE_11AC

2591

case (eHDD_DOT11_MODE_11ac_ONLY):

2592

return eCSR_DOT11_MODE_11ac_ONLY;

2593

case (eHDD_DOT11_MODE_11ac):

2594

return eCSR_DOT11_MODE_11ac;

2595

#endif

Jeff Johnson

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

[diff] [blame]

2596

case (eHDD_DOT11_MODE_AUTO):

2597

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2603

{

2604

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2605

tSmeBtcConfig btcParams;

2606

2607

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2608

2609

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2610

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2611

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2612

Jeff Johnson

32d95a3

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

[diff] [blame]

2613

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2614

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2615

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2616

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2617

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2618

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2619

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2620

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2621

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2622

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2623

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2624

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2625

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2626

Jeff Johnson

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

[diff] [blame]

2627

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2628

}

2629

2630

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

2631

{

2632

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2633

2634

tPmcBmpsConfigParams bmpsParams;

2635

2636

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

2637

2638

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

2639

{

2640

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

2641

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2642

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2643

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2644

}

2645

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

2646

{

2647

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

2648

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2649

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2650

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2651

}

2652

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

2653

{

2654

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

2655

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2656

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2657

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2658

}

2659

2660

if (pConfig->fIsImpsEnabled)

2661

{

2662

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2667

}

2668

2669

if (pConfig->fIsBmpsEnabled)

2670

{

2671

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2676

}

2677

2678

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2679

2680

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

2681

{

2682

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

2683

}

2684

2685

if(pConfig->fIsAutoBmpsTimerEnabled)

2686

{

2687

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2693

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 )

2698

{

2699

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2703

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

2704

{

2705

int val;

2706

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

2707

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

2708

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

2709

{

2710

intArray[*len] = (tANI_U8) val;

2711

*len += 1;

2712

}

2713

s = strpbrk( s, "," );

2714

if( s )

2715

s++;

2716

}

Jeff Johnson

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

[diff] [blame]

2717

2718

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2725

{

2726

v_BOOL_t fStatus = TRUE;

2727

2728

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2729

tSirMacHTCapabilityInfo htCapInfo;

2730

Jeff Johnson

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

[diff] [blame]

2731

2732

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2733

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

2734

{

2735

fStatus = FALSE;

2736

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

2737

}

2738

2739

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

2740

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2741

{

2742

fStatus = FALSE;

2743

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

2744

}

2745

2746

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

2747

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2748

{

2749

fStatus = FALSE;

2750

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

2751

}

2752

2753

if ( 0 != pConfig->Cfg1Id )

2754

{

2755

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

2756

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2757

{

2758

fStatus = FALSE;

2759

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

}

}

if ( 0 != pConfig->Cfg2Id )

2765

{

2766

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

2767

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2768

{

2769

fStatus = FALSE;

2770

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

}

}

if ( 0 != pConfig->Cfg3Id )

2775

{

2776

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

2777

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2778

{

2779

fStatus = FALSE;

2780

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

}

}

if ( 0 != pConfig->Cfg4Id )

2785

{

2786

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

2787

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2788

{

2789

fStatus = FALSE;

2790

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

}

}

if ( 0 != pConfig->Cfg5Id )

2795

{

2796

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

2797

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2798

{

2799

fStatus = FALSE;

2800

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

}

}

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

2805

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2806

{

2807

fStatus = FALSE;

2808

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

2809

}

2810

2811

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

2812

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2813

{

2814

fStatus = FALSE;

2815

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

2816

}

2817

2818

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2819

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

2820

{

2821

fStatus = FALSE;

2822

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

2823

}

2824

2825

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

2826

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2827

{

2828

fStatus = FALSE;

2829

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

2830

}

2831

2832

if (pConfig->fIsAutoIbssBssid)

2833

{

2834

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

2835

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

2836

{

2837

fStatus = FALSE;

2838

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

}

}

else

{

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

2844

{

2845

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2846

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

2847

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

2848

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

2849

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

2850

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

2851

{

2852

fStatus = FALSE;

2853

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,

2864

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2865

{

2866

fStatus = FALSE;

2867

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

2868

}

2869

2870

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

2871

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2872

{

2873

fStatus = FALSE;

2874

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

2875

}

2876

2877

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

2878

{

2879

fStatus = FALSE;

2880

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

2881

}

2882

2883

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

2884

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2885

{

2886

fStatus = FALSE;

2887

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

2888

}

2889

2890

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

2891

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2892

{

2893

fStatus = FALSE;

2894

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

2895

}

2896

Jeff Johnson

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

[diff] [blame]

2897

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

2898

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

2899

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2900

{

2901

fStatus = FALSE;

2902

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,

2907

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2908

{

2909

fStatus = FALSE;

2910

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

2911

}

2912

2913

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

2914

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2915

{

2916

fStatus = FALSE;

2917

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

2918

}

2919

2920

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

2921

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2922

{

2923

fStatus = FALSE;

2924

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

2925

}

2926

Gopichand Nakkala

98a98af

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

[diff] [blame^]

2927

#ifdef FEATURE_WLAN_LFR

2928

if (pConfig->isFastRoamIniFeatureEnabled)

2929

{

2930

pConfig->fEnableFwRssiMonitoring = TRUE;

2931

}

2932

#endif

2933

#ifdef FEATURE_WLAN_CCX

2934

if (pConfig->isCcxIniFeatureEnabled)

2935

{

2936

pConfig->fEnableFwRssiMonitoring = TRUE;

2937

}

2938

#endif

Jeff Johnson

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

[diff] [blame]

2939

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

2940

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2941

{

2942

fStatus = FALSE;

2943

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

2944

}

2945

2946

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

2947

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2948

{

2949

fStatus = FALSE;

2950

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

2951

}

2952

2953

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

2954

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2955

{

2956

fStatus = FALSE;

2957

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

2958

}

2959

2960

#ifdef WLAN_SOFTAP_FEATURE

2961

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

2962

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2963

{

2964

fStatus = FALSE;

2965

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

2966

}

2967

2968

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

2969

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2970

{

2971

fStatus = FALSE;

2972

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

2973

}

2974

Jeff Johnson

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

[diff] [blame]

2975

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

2976

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2977

{

2978

fStatus = FALSE;

2979

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

2980

}

2981

2982

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

2983

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2984

{

2985

fStatus = FALSE;

2986

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

2991

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

2992

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2993

{

2994

fStatus = FALSE;

2995

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

2996

}

2997

2998

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

2999

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3000

{

3001

fStatus = FALSE;

3002

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

3003

}

3004

3005

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

3006

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3007

{

3008

fStatus = FALSE;

3009

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

3010

}

3011

3012

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

3013

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3014

#endif

3015

3016

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

3017

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3018

{

3019

fStatus = FALSE;

3020

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

3021

}

3022

3023

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

3024

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3025

{

3026

fStatus = FALSE;

3027

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

3028

}

3029

3030

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

3031

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3032

{

3033

fStatus = FALSE;

3034

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

3035

}

3036

3037

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

3038

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3039

{

3040

fStatus = FALSE;

3041

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

3042

}

3043

3044

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

3045

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3046

{

3047

fStatus = FALSE;

3048

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

3049

}

3050

3051

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

3052

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3053

{

3054

fStatus = FALSE;

3055

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

3056

}

3057

3058

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

3059

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3060

{

3061

fStatus = FALSE;

3062

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

3063

}

3064

3065

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

3066

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3067

{

3068

fStatus = FALSE;

3069

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

3070

}

3071

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

3072

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3073

{

3074

fStatus = FALSE;

3075

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

3076

}

3077

3078

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

3079

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3080

{

3081

fStatus = FALSE;

3082

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

3083

}

3084

3085

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

3086

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3087

{

3088

fStatus = FALSE;

3089

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

3090

}

3091

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3092

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

3093

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3094

{

3095

fStatus = FALSE;

3096

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

3097

}

3098

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

3099

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3100

{

3101

fStatus = FALSE;

3102

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

3103

}

3104

3105

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

3106

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3107

{

3108

fStatus = FALSE;

3109

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

3110

}

3111

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

3112

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3113

{

3114

fStatus = FALSE;

3115

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,

3120

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3121

{

3122

fStatus = FALSE;

3123

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

3124

}

3125

3126

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3127

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3128

==eHAL_STATUS_FAILURE)

3129

{

3130

fStatus = FALSE;

3131

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

3132

}

3133

3134

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3135

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3136

==eHAL_STATUS_FAILURE)

3137

{

3138

fStatus = FALSE;

3139

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

3140

}

3141

3142

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3143

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

3144

{

3145

fStatus = FALSE;

3146

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

3147

}

3148

Jeff Johnson

d13512a

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

[diff] [blame]

3149

3150

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

3151

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3152

{

3153

fStatus = FALSE;

3154

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

3155

}

3156

Jeff Johnson

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

[diff] [blame]

3157

#ifdef WLAN_FEATURE_11AC

3158

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

3159

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

3160

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

3161

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

3162

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3163

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3169

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

3170

3171

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3172

temp, NULL, eANI_BOOLEAN_FALSE)

3173

==eHAL_STATUS_FAILURE)

3174

{

3175

fStatus = FALSE;

3176

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

3177

}

3178

3179

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

3180

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

3181

3182

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3183

temp, NULL, eANI_BOOLEAN_FALSE)

3184

==eHAL_STATUS_FAILURE)

3185

{

3186

fStatus = FALSE;

3187

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

3188

}

3189

3190

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

3191

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

3192

3193

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3194

temp, NULL, eANI_BOOLEAN_FALSE)

3195

==eHAL_STATUS_FAILURE)

3196

{

3197

fStatus = FALSE;

3198

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]

3204

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

3205

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3206

{

3207

fStatus = FALSE;

3208

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

3209

}

3210

Pratik Bhalgat

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

[diff] [blame]

3211

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3212

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3213

==eHAL_STATUS_FAILURE)

3214

{

3215

fStatus = FALSE;

3216

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

3217

}

3218

3219

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

3220

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3221

3222

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3223

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

3224

==eHAL_STATUS_FAILURE)

3225

{

3226

fStatus = FALSE;

3227

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

3228

}

3229

3230

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3231

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3232

==eHAL_STATUS_FAILURE)

3233

{

3234

fStatus = FALSE;

3235

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

3236

}

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3237

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3238

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3239

==eHAL_STATUS_FAILURE)

3240

{

3241

fStatus = FALSE;

3242

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

3243

}

Pratik Bhalgat

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

[diff] [blame]

3244

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3250

3251

\brief hdd_init_set_sme_config() -

3252

3253

This function initializes the sme configuration parameters

3254

3255

\param - pHddCtx - Pointer to the HDD Adapter.

3256

3257

\return - 0 for success, non zero for failure

3258

3259

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

3260

3261

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3262

{

3263

VOS_STATUS status = VOS_STATUS_SUCCESS;

3264

eHalStatus halStatus;

3265

tSmeConfigParams smeConfig;

3266

3267

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3268

3269

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3270

3271

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3272

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

3273

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

3274

3275

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3276

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3277

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

Jeff Johnson

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

[diff] [blame]

3278

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3279

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3280

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3281

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3282

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3283

3284

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

3285

3286

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3287

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3288

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3289

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3290

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3291

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3292

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3293

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3294

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3295

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3296

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3297

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3298

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3299

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3300

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3301

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3302

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3303

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3304

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3305

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3306

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3307

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3308

#ifdef WLAN_AP_STA_CONCURRENCY

3309

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3310

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3311

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3312

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3313

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

2012-12-17 13:04:30 -0800

[diff] [blame]

3314

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3315

#endif

Jeff Johnson

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

[diff] [blame]

3316

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3317

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3318

3319

#if defined WLAN_FEATURE_VOWIFI

3320

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3321

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3322

#endif

3323

//Remaining config params not obtained from registry

3324

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3325

#ifdef WLAN_FEATURE_11AC

3326

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3327

#endif

Jeff Johnson

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

[diff] [blame]

3328

smeConfig.csrConfig.AdHocChannel5G = 44;

3329

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3330

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3331

smeConfig.csrConfig.Is11hSupportEnabled = 1;

Jeff Johnson

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

[diff] [blame]

3332

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

3333

smeConfig.csrConfig.cbChoice = 0;

3334

smeConfig.csrConfig.bgScanInterval = 0;

3335

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3336

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3337

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3338

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3339

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3340

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

3341

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3342

#endif

Jeff Johnson

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

[diff] [blame]

3343

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3344

Jeff Johnson

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

[diff] [blame]

3345

//FIXME 11d config is hardcoded

3346

#ifdef WLAN_SOFTAP_FEATURE

3347

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3348

#endif

3349

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

3350

3351

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

3352

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

3353

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

3354

3355

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3360

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

3361

3362

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

3363

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

3364

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3365

}

3366

#endif

3367

hdd_set_power_save_config(pHddCtx, &smeConfig);

3368

hdd_set_btc_config(pHddCtx);

3369

3370

#ifdef WLAN_FEATURE_VOWIFI_11R

3371

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

3372

#endif

Jeff Johnson

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

[diff] [blame]

3373

#ifdef FEATURE_WLAN_LFR

3374

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame^]

3375

if( pConfig->isFastRoamIniFeatureEnabled )

3376

{

3377

pConfig->isFastTransitionEnabled = TRUE;

3378

}

Jeff Johnson

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

[diff] [blame]

3379

#endif

Jeff Johnson

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

[diff] [blame]

3380

#ifdef FEATURE_WLAN_CCX

3381

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame^]

3382

if( pConfig->isCcxIniFeatureEnabled )

3383

{

3384

pConfig->isFastTransitionEnabled = TRUE;

3385

}

Jeff Johnson

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

[diff] [blame]

3386

#endif

Jeff Johnson

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

[diff] [blame]

3387

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

3388

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3389

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3390

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3391

#endif

3392

3393

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3394

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

3395

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

3396

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

3397

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

3398

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

3399

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

3400

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

3401

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3402

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3403

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3404

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3405

#endif

3406

3407

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3408

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3409

3410

//Enable/Disable MCC

3411

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3412

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3413

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

3414

//Scan Results Aging Time out value

3415

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3416

Jeff Johnson

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

[diff] [blame]

3417

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

3418

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3419

{

3420

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3429

3430

\brief hdd_execute_config_command() -

3431

3432

This function executes an arbitrary configuration set command

3433

3434

\param - pHddCtx - Pointer to the HDD Adapter.

3435

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

3436

3437

3438

\return - 0 for success, non zero for failure

3439

3440

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

3441

3442

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3443

{

3444

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

3445

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;

3454

unsigned int idx;

3455

unsigned int i;

3456

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3457

int rv;

Jeff Johnson

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

[diff] [blame]

3458

3459

// assume failure until proven otherwise

3460

vstatus = VOS_STATUS_E_FAILURE;

3461

3462

// clone the command so that we can manipulate it

3463

clone = kstrdup(command, GFP_ATOMIC);

3464

if (NULL == clone)

3465

{

3466

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3467

__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

3472

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

3473

pCmd = clone;

3474

3475

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

3481

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3486

name = pCmd;

3487

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]

3495

__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

3505

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3506

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3511

if ('\0' == *value_str)

3512

{

3513

// did not find a value

3514

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3515

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3520

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

3521

{

3522

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

{

// found a match

break;

}

}

if (tableSize == idx)

3529

{

3530

// did not match the name

3531

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3532

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3537

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

3538

{

3539

// does not support dynamic configuration

3540

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3541

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

3546

3547

switch (pRegEntry->RegType)

3548

{

3549

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3550

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

3551

if (rv < 0)

3552

goto done;

Jeff Johnson

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

[diff] [blame]

3553

if (value < pRegEntry->VarMin)

3554

{

3555

// out of range

3556

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3557

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3558

goto done;

3559

}

3560

if (value > pRegEntry->VarMax)

3561

{

3562

// out of range

3563

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3564

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3565

goto done;

3566

}

3567

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

3568

break;

3569

3570

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3571

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

3572

if (rv < 0)

3573

goto done;

Jeff Johnson

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

[diff] [blame]

3574

if (value < pRegEntry->VarMin)

3575

{

3576

// out of range

3577

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3578

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3579

goto done;

3580

}

3581

if (value > pRegEntry->VarMax)

3582

{

3583

// out of range

3584

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3585

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3586

goto done;

3587

}

3588

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

3589

break;

3590

3591

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3592

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

3593

if (rv < 0)

3594

goto done;

Jeff Johnson

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

[diff] [blame]

3595

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

3596

{

3597

// out of range

3598

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3599

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

Jeff Johnson

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

[diff] [blame]

3600

goto done;

3601

}

3602

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

3603

{

3604

// out of range

3605

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3606

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

Jeff Johnson

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

[diff] [blame]

3607

goto done;

3608

}

3609

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

3610

break;

3611

3612

case WLAN_PARAM_String:

3613

len_value_str = strlen(value_str);

3614

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

{

// too big

hddLog(LOGE,

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

3619

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3620

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3621

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

3622

goto done;

3623

}

3624

// copy string plus NUL

3625

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

3626

break;

3627

3628

case WLAN_PARAM_MacAddr:

3629

len_value_str = strlen(value_str);

3630

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3635

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3636

__func__, value_str,

Jeff Johnson