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

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

[diff] [blame]

2269

#ifdef WLAN_FEATURE_11AC

2270

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

2271

#endif

2272

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

2273

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

2274

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]

2275

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]

2276

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]

2277

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

2282

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2283

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

2284

{

2285

unsigned int idx;

2286

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2287

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

2288

v_U32_t value;

2289

char valueStr[CFG_VALUE_MAX_LEN];

2290

char configStr[CFG_ENTRY_MAX_LEN];

2291

char *fmt;

2292

void *pField;

2293

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2298

*pCur = '\0';

2299

2300

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

2301

{

2302

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

2303

2304

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

2305

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2306

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2307

{

2308

value = 0;

2309

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

2310

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

2323

}

2324

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2325

{

2326

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

2327

}

2328

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2329

{

2330

pMacAddr = (v_MACADDR_t *) pField;

2331

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2332

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

2343

}

2344

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2349

"*" : "");

2350

2351

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

2352

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

2353

#ifdef RETURN_IN_BUFFER

2354

if (curlen <= buflen)

2355

{

2356

// copy string + '\0'

2357

memcpy(pCur, configStr, curlen+1);

2358

2359

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2366

return VOS_STATUS_E_RESOURCES;

2367

}

2368

#else

2369

printk(KERN_CRIT "%s", configStr);

2370

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2375

// notify application that output is in system log

2376

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

2377

#endif // RETURN_IN_BUFFER

2378

2379

return VOS_STATUS_SUCCESS;

2380

}

2381

2382

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

2383

char *name, char** value)

2384

{

2385

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2386

unsigned long i;

2387

2388

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

2389

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

2390

*value = iniTable[i].value;

2391

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

2392

WLAN_INI_FILE, name, *value);

2393

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2401

{

2402

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

2403

return c-'0';

2404

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

2405

return c-'a'+10;

2406

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)

2414

{

2415

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2416

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2417

unsigned int idx;

2418

void *pField;

2419

char *value_str = NULL;

2420

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2425

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2426

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

2427

v_U32_t cbOutString;

2428

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2429

int rv;

Jeff Johnson

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

[diff] [blame]

2430

2431

// sanity test

2432

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2433

{

2434

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]

2435

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2436

}

2437

2438

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

2439

{

2440

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

2441

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

2442

2443

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

2444

2445

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

2446

{

2447

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

2448

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2449

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2450

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2455

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2456

{

2457

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

2458

// If not, use the default value.

2459

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2460

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

2461

if (rv < 0) {

2462

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

2463

__func__, pRegEntry->RegName);

2464

value = pRegEntry->VarDefault;

2465

}

Jeff Johnson

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

[diff] [blame]

2466

}

2467

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2468

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

2469

if (rv < 0) {

2470

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

2471

__func__, pRegEntry->RegName);

2472

value = pRegEntry->VarDefault;

2473

}

Jeff Johnson

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

[diff] [blame]

2474

}

2475

else {

2476

value = pRegEntry->VarDefault;

2477

}

2478

2479

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

2480

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2481

{

2482

if ( value > pRegEntry->VarMax )

2483

{

2484

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2485

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

Jeff Johnson

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

[diff] [blame]

2486

value = pRegEntry->VarMax;

2487

}

2488

2489

if ( value < pRegEntry->VarMin )

2490

{

2491

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2492

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

Jeff Johnson

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

[diff] [blame]

2493

value = pRegEntry->VarMin;

2494

}

2495

}

2496

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

2497

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2498

{

2499

if ( value > pRegEntry->VarMax )

2500

{

2501

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]

2502

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

Jeff Johnson

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

[diff] [blame]

2503

value = pRegEntry->VarDefault;

2504

}

2505

2506

if ( value < pRegEntry->VarMin )

2507

{

2508

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]

2509

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

Jeff Johnson

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

[diff] [blame]

2510

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2515

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

2516

}

2517

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2518

{

2519

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

2520

// If not, use the default value.

2521

if (VOS_STATUS_SUCCESS == match_status)

2522

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2523

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

2524

if (rv < 0) {

2525

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

2526

__func__, pRegEntry->RegName);

2527

svalue = (v_S31_t)pRegEntry->VarDefault;

2528

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2533

}

2534

2535

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

2536

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2537

{

2538

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

2539

{

2540

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2541

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

Jeff Johnson

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

[diff] [blame]

2542

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

2543

svalue = (v_S31_t)pRegEntry->VarMax;

2544

}

2545

2546

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

2547

{

2548

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2549

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

Jeff Johnson

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

[diff] [blame]

2550

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

2551

svalue = (v_S31_t)pRegEntry->VarMin;

2552

}

2553

}

2554

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

2555

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2556

{

2557

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

2558

{

2559

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

2560

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2561

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2562

(int)pRegEntry->VarMax,

2563

(int)pRegEntry->VarDefault );

2564

svalue = (v_S31_t)pRegEntry->VarDefault;

2565

}

2566

2567

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

2568

{

2569

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

2570

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2571

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2572

(int)pRegEntry->VarMin,

2573

(int)pRegEntry->VarDefault);

2574

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2579

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

2580

}

2581

// Handle string parameters

2582

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2583

{

2584

#ifdef WLAN_CFG_DEBUG

2585

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

2586

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

2587

#endif

2588

2589

if ( match_status == VOS_STATUS_SUCCESS)

2590

{

2591

len_value_str = strlen(value_str);

2592

2593

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

2594

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]

2595

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

Jeff Johnson

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

[diff] [blame]

2596

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

2597

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

2598

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

}

else

{

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

2603

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

}

}

else

{

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

2609

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

2610

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

2611

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

2612

}

2613

}

2614

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2615

{

2616

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2617

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2618

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

Jeff Johnson

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

[diff] [blame]

2619

continue;

2620

}

2621

candidate = (char*)pRegEntry->VarDefault;

2622

if ( match_status == VOS_STATUS_SUCCESS) {

2623

len_value_str = strlen(value_str);

2624

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

2625

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]

2626

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

Jeff Johnson

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

[diff] [blame]

2627

}

2628

else

2629

candidate = value_str;

2630

}

2631

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

2632

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

2633

{

2634

((char*)pField)[i] =

2635

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

2641

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2642

}

2643

2644

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

2645

if( (match_status == VOS_STATUS_SUCCESS) &&

2646

(idx < MAX_CFG_INI_ITEMS) )

2647

{

2648

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

}

}

print_hdd_cfg(pHddCtx);

2653

2654

return( ret_status );

2655

}

2656

2657

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2662

return eCSR_DOT11_MODE_abg;

2663

case (eHDD_DOT11_MODE_11b):

2664

return eCSR_DOT11_MODE_11b;

2665

case (eHDD_DOT11_MODE_11g):

2666

return eCSR_DOT11_MODE_11g;

2667

default:

2668

case (eHDD_DOT11_MODE_11n):

2669

return eCSR_DOT11_MODE_11n;

2670

case (eHDD_DOT11_MODE_11g_ONLY):

2671

return eCSR_DOT11_MODE_11g_ONLY;

2672

case (eHDD_DOT11_MODE_11n_ONLY):

2673

return eCSR_DOT11_MODE_11n_ONLY;

2674

case (eHDD_DOT11_MODE_11b_ONLY):

2675

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2676

#ifdef WLAN_FEATURE_11AC

2677

case (eHDD_DOT11_MODE_11ac_ONLY):

2678

return eCSR_DOT11_MODE_11ac_ONLY;

2679

case (eHDD_DOT11_MODE_11ac):

2680

return eCSR_DOT11_MODE_11ac;

2681

#endif

Jeff Johnson

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

[diff] [blame]

2682

case (eHDD_DOT11_MODE_AUTO):

2683

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2689

{

2690

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2691

tSmeBtcConfig btcParams;

2692

2693

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2694

2695

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2696

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2697

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2698

Jeff Johnson

32d95a3

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

[diff] [blame]

2699

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2700

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2701

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2702

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2703

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2704

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2705

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2706

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2707

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2708

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2709

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2710

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2711

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2712

Jeff Johnson

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

[diff] [blame]

2713

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2714

}

2715

2716

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

2717

{

2718

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2719

2720

tPmcBmpsConfigParams bmpsParams;

2721

2722

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

2723

2724

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

2725

{

2726

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

2727

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2728

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2729

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2730

}

2731

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

2732

{

2733

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

2734

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2735

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2736

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2737

}

2738

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

2739

{

2740

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

2741

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2742

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2743

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2744

}

2745

2746

if (pConfig->fIsImpsEnabled)

2747

{

2748

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2753

}

2754

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

2755

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

2756

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

2757

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

2758

Jeff Johnson

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

[diff] [blame]

2759

if (pConfig->fIsBmpsEnabled)

2760

{

2761

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2766

}

2767

2768

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2769

2770

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

2771

{

2772

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

2773

}

2774

2775

if(pConfig->fIsAutoBmpsTimerEnabled)

2776

{

2777

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2783

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 )

2788

{

2789

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2793

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

2794

{

2795

int val;

2796

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

2797

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

2798

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

2799

{

2800

intArray[*len] = (tANI_U8) val;

2801

*len += 1;

2802

}

2803

s = strpbrk( s, "," );

2804

if( s )

2805

s++;

2806

}

Jeff Johnson

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

[diff] [blame]

2807

2808

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2815

{

2816

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

2817

#ifdef WLAN_SOFTAP_VSTA_FEATURE

2818

tANI_U32 val;

2819

#endif

Jeff Johnson

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

[diff] [blame]

2820

2821

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2822

tSirMacHTCapabilityInfo htCapInfo;

2823

Jeff Johnson

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

[diff] [blame]

2824

2825

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2826

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

2827

{

2828

fStatus = FALSE;

2829

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

2830

}

2831

2832

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

2833

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2834

{

2835

fStatus = FALSE;

2836

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

2837

}

2838

2839

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

2840

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2841

{

2842

fStatus = FALSE;

2843

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

2844

}

2845

2846

if ( 0 != pConfig->Cfg1Id )

2847

{

2848

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

2849

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2850

{

2851

fStatus = FALSE;

2852

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

}

}

if ( 0 != pConfig->Cfg2Id )

2858

{

2859

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

2860

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2861

{

2862

fStatus = FALSE;

2863

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

}

}

if ( 0 != pConfig->Cfg3Id )

2868

{

2869

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

2870

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2871

{

2872

fStatus = FALSE;

2873

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

}

}

if ( 0 != pConfig->Cfg4Id )

2878

{

2879

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

2880

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2881

{

2882

fStatus = FALSE;

2883

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

}

}

if ( 0 != pConfig->Cfg5Id )

2888

{

2889

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

2890

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2891

{

2892

fStatus = FALSE;

2893

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

}

}

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

2898

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2899

{

2900

fStatus = FALSE;

2901

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

2902

}

2903

2904

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

2905

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2906

{

2907

fStatus = FALSE;

2908

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

2909

}

2910

2911

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2912

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

2913

{

2914

fStatus = FALSE;

2915

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

2916

}

2917

2918

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

2919

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2920

{

2921

fStatus = FALSE;

2922

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

2923

}

2924

2925

if (pConfig->fIsAutoIbssBssid)

2926

{

2927

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

2928

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

2929

{

2930

fStatus = FALSE;

2931

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

}

}

else

{

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

2937

{

2938

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2939

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

2940

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

2941

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

2942

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

2943

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

2944

{

2945

fStatus = FALSE;

2946

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,

2957

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2958

{

2959

fStatus = FALSE;

2960

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

2961

}

2962

2963

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

2964

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2965

{

2966

fStatus = FALSE;

2967

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

2968

}

2969

2970

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

2971

{

2972

fStatus = FALSE;

2973

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

2974

}

2975

2976

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

2977

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2978

{

2979

fStatus = FALSE;

2980

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

2981

}

2982

2983

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

2984

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2985

{

2986

fStatus = FALSE;

2987

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

2988

}

2989

Jeff Johnson

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

[diff] [blame]

2990

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

2991

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2992

{

2993

fStatus = FALSE;

2994

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

2995

}

2996

2997

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

2998

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2999

{

3000

fStatus = FALSE;

3001

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

3002

}

3003

3004

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

3005

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3006

{

3007

fStatus = FALSE;

3008

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

3009

}

3010

Gopichand Nakkala

98a98af

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

[diff] [blame]

3011

#ifdef FEATURE_WLAN_LFR

3012

if (pConfig->isFastRoamIniFeatureEnabled)

3013

{

3014

pConfig->fEnableFwRssiMonitoring = TRUE;

3015

}

3016

#endif

3017

#ifdef FEATURE_WLAN_CCX

3018

if (pConfig->isCcxIniFeatureEnabled)

3019

{

3020

pConfig->fEnableFwRssiMonitoring = TRUE;

3021

}

3022

#endif

Jeff Johnson

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

[diff] [blame]

3023

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

3024

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3025

{

3026

fStatus = FALSE;

3027

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

3028

}

3029

3030

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

3031

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3032

{

3033

fStatus = FALSE;

3034

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

3035

}

3036

3037

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

3038

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3039

{

3040

fStatus = FALSE;

3041

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

3042

}

3043

3044

#ifdef WLAN_SOFTAP_FEATURE

3045

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

3046

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3047

{

3048

fStatus = FALSE;

3049

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

3050

}

3051

3052

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

3053

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3054

{

3055

fStatus = FALSE;

3056

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

3057

}

3058

Jeff Johnson

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

[diff] [blame]

3059

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

3060

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3061

{

3062

fStatus = FALSE;

3063

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

3064

}

3065

3066

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

3067

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3068

{

3069

fStatus = FALSE;

3070

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

3075

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

3076

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3077

{

3078

fStatus = FALSE;

3079

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

3080

}

3081

3082

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

3083

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3084

{

3085

fStatus = FALSE;

3086

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

3087

}

3088

3089

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

3090

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3091

{

3092

fStatus = FALSE;

3093

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

3094

}

3095

3096

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

3097

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3098

#endif

3099

3100

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

3101

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3102

{

3103

fStatus = FALSE;

3104

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

3105

}

3106

3107

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

3108

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3109

{

3110

fStatus = FALSE;

3111

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

3112

}

3113

3114

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

3115

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3116

{

3117

fStatus = FALSE;

3118

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

3119

}

3120

3121

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

3122

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3123

{

3124

fStatus = FALSE;

3125

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

3126

}

3127

3128

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

3129

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3130

{

3131

fStatus = FALSE;

3132

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

3133

}

3134

3135

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

3136

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3137

{

3138

fStatus = FALSE;

3139

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

3140

}

3141

3142

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

3143

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3144

{

3145

fStatus = FALSE;

3146

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

3147

}

3148

3149

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

3150

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3151

{

3152

fStatus = FALSE;

3153

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

3154

}

3155

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

3156

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3157

{

3158

fStatus = FALSE;

3159

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

3160

}

3161

3162

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

3163

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3164

{

3165

fStatus = FALSE;

3166

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

3167

}

3168

3169

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

3170

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3171

{

3172

fStatus = FALSE;

3173

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

3174

}

3175

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3176

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

3177

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3178

{

3179

fStatus = FALSE;

3180

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

3181

}

3182

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

3183

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3184

{

3185

fStatus = FALSE;

3186

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

3187

}

3188

3189

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

3190

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3191

{

3192

fStatus = FALSE;

3193

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

3194

}

3195

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

3196

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3197

{

3198

fStatus = FALSE;

3199

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,

3204

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3205

{

3206

fStatus = FALSE;

3207

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

3208

}

3209

3210

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3211

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3212

==eHAL_STATUS_FAILURE)

3213

{

3214

fStatus = FALSE;

3215

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

3216

}

3217

3218

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3219

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3220

==eHAL_STATUS_FAILURE)

3221

{

3222

fStatus = FALSE;

3223

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

3224

}

3225

3226

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3227

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

3228

{

3229

fStatus = FALSE;

3230

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

3231

}

3232

Jeff Johnson

d13512a

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

[diff] [blame]

3233

3234

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

3235

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3236

{

3237

fStatus = FALSE;

3238

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

3239

}

3240

Jeff Johnson

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

[diff] [blame]

3241

#ifdef WLAN_FEATURE_11AC

3242

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

3243

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

3244

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

3245

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

3246

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3247

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3253

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

3254

3255

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3256

temp, NULL, eANI_BOOLEAN_FALSE)

3257

==eHAL_STATUS_FAILURE)

3258

{

3259

fStatus = FALSE;

3260

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

3261

}

3262

3263

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

3264

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

3265

3266

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3267

temp, NULL, eANI_BOOLEAN_FALSE)

3268

==eHAL_STATUS_FAILURE)

3269

{

3270

fStatus = FALSE;

3271

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

3272

}

3273

3274

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

3275

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

3276

3277

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3278

temp, NULL, eANI_BOOLEAN_FALSE)

3279

==eHAL_STATUS_FAILURE)

3280

{

3281

fStatus = FALSE;

3282

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]

3288

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

3289

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3290

{

3291

fStatus = FALSE;

3292

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

3293

}

3294

Pratik Bhalgat

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

[diff] [blame]

3295

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3296

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3297

==eHAL_STATUS_FAILURE)

3298

{

3299

fStatus = FALSE;

3300

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

3301

}

3302

3303

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

3304

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3305

3306

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3307

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

3308

==eHAL_STATUS_FAILURE)

3309

{

3310

fStatus = FALSE;

3311

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

3312

}

3313

3314

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3315

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3316

==eHAL_STATUS_FAILURE)

3317

{

3318

fStatus = FALSE;

3319

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

3320

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3321

3322

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3323

if(pConfig->fEnableVSTASupport)

3324

{

3325

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

3326

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3327

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3332

}

3333

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

3334

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3335

{

3336

fStatus = FALSE;

3337

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

3338

}

3339

#endif

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3340

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3341

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3342

==eHAL_STATUS_FAILURE)

3343

{

3344

fStatus = FALSE;

3345

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

3346

}

Pratik Bhalgat

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

[diff] [blame]

3347

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3348

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

3349

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3350

{

3351

fStatus = FALSE;

3352

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

3353

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3359

3360

\brief hdd_init_set_sme_config() -

3361

3362

This function initializes the sme configuration parameters

3363

3364

\param - pHddCtx - Pointer to the HDD Adapter.

3365

3366

\return - 0 for success, non zero for failure

3367

3368

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

3369

3370

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3371

{

3372

VOS_STATUS status = VOS_STATUS_SUCCESS;

3373

eHalStatus halStatus;

3374

tSmeConfigParams smeConfig;

3375

3376

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3377

3378

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3379

3380

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3381

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

3382

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

3383

3384

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3385

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3386

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

Jeff Johnson

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

[diff] [blame]

3387

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3388

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3389

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3390

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3391

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3392

3393

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

3394

3395

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3396

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3397

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3398

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3399

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3400

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3401

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3402

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3403

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3404

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3405

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3406

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3407

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3408

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3409

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3410

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3411

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3412

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3413

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3414

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3415

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3416

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3417

#ifdef WLAN_AP_STA_CONCURRENCY

3418

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3419

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3420

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3421

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3422

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

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

[diff] [blame]

3423

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3424

#endif

Jeff Johnson

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

[diff] [blame]

3425

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3426

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3427

3428

#if defined WLAN_FEATURE_VOWIFI

3429

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3430

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3431

#endif

3432

//Remaining config params not obtained from registry

3433

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3434

#ifdef WLAN_FEATURE_11AC

3435

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame^]

3436

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Jeff Johnson

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

[diff] [blame]

3437

#endif

Jeff Johnson

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

[diff] [blame]

3438

smeConfig.csrConfig.AdHocChannel5G = 44;

3439

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3440

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3441

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3442

if (pConfig->nBandCapability == eCSR_BAND_24)

3443

{

3444

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3445

} else {

3446

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3447

}

Jeff Johnson

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

[diff] [blame]

3448

smeConfig.csrConfig.cbChoice = 0;

3449

smeConfig.csrConfig.bgScanInterval = 0;

3450

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3451

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3452

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3453

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3454

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3455

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

3456

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3457

#endif

Jeff Johnson

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

[diff] [blame]

3458

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3459

Jeff Johnson

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

[diff] [blame]

3460

//FIXME 11d config is hardcoded

3461

#ifdef WLAN_SOFTAP_FEATURE

3462

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3463

#endif

3464

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

3465

3466

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

3467

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

3468

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

3469

3470

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3475

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

3476

3477

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

3478

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

3479

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3480

}

3481

#endif

3482

hdd_set_power_save_config(pHddCtx, &smeConfig);

3483

hdd_set_btc_config(pHddCtx);

3484

3485

#ifdef WLAN_FEATURE_VOWIFI_11R

3486

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

3487

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3488

#ifdef FEATURE_WLAN_LFR

3489

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3490

if( pConfig->isFastRoamIniFeatureEnabled )

3491

{

3492

pConfig->isFastTransitionEnabled = TRUE;

3493

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

3494

#endif

Jeff Johnson

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

[diff] [blame]

3495

#ifdef FEATURE_WLAN_CCX

3496

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3497

if( pConfig->isCcxIniFeatureEnabled )

3498

{

3499

pConfig->isFastTransitionEnabled = TRUE;

3500

}

Jeff Johnson

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

[diff] [blame]

3501

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3502

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

3503

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3504

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3505

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3506

#endif

3507

3508

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3509

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

3510

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

3511

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

3512

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

3513

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

3514

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

3515

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

3516

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3517

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3518

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3519

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3520

#endif

3521

3522

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3523

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3524

3525

//Enable/Disable MCC

3526

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3527

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3528

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

3529

//Scan Results Aging Time out value

3530

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3531

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

3532

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

3533

Jeff Johnson

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

[diff] [blame]

3534

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

3535

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3536

{

3537

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3546

3547

\brief hdd_execute_config_command() -

3548

3549

This function executes an arbitrary configuration set command

3550

3551

\param - pHddCtx - Pointer to the HDD Adapter.

3552

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

3553

3554

3555

\return - 0 for success, non zero for failure

3556

3557

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

3558

3559

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3560

{

3561

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

3562

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;

3571

unsigned int idx;

3572

unsigned int i;

3573

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3574

int rv;

Jeff Johnson

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

[diff] [blame]

3575

3576

// assume failure until proven otherwise

3577

vstatus = VOS_STATUS_E_FAILURE;

3578

3579

// clone the command so that we can manipulate it

3580

clone = kstrdup(command, GFP_ATOMIC);

3581

if (NULL == clone)

3582

{

3583

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3584

__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

3589

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

3590

pCmd = clone;

3591

3592

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

3598

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3603

name = pCmd;

3604

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]

3612

__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

3622

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3623

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3628

if ('\0' == *value_str)

3629

{

3630

// did not find a value

3631

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3632

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3637

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

3638

{

3639

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

{

// found a match

break;

}

}

if (tableSize == idx)

3646

{

3647

// did not match the name

3648

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3649

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3654

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

3655

{

3656

// does not support dynamic configuration

3657

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3658

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

3663

3664

switch (pRegEntry->RegType)

3665

{

3666

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3667

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

3668

if (rv < 0)

3669

goto done;

Jeff Johnson

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

[diff] [blame]

3670

if (value < pRegEntry->VarMin)

3671

{

3672

// out of range

3673

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3674

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3675

goto done;

3676

}

3677

if (value > pRegEntry->VarMax)

3678

{

3679

// out of range

3680

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3681

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3682

goto done;

3683

}

3684

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

3685

break;

3686

3687

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3688

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

3689

if (rv < 0)

3690

goto done;

Jeff Johnson

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

[diff] [blame]

3691

if (value < pRegEntry->VarMin)

3692

{

3693

// out of range

3694

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3695

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3696

goto done;

3697

}

3698

if (value > pRegEntry->VarMax)

3699

{

3700

// out of range

3701

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3702

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3703

goto done;

3704

}

3705

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

3706

break;

3707

3708

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3709

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

3710

if (rv < 0)

3711

goto done;

Jeff Johnson

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

[diff] [blame]

3712

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

3713

{

3714

// out of range

3715

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3716

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

Jeff Johnson

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

[diff] [blame]

3717

goto done;

3718

}

3719

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

3720

{

3721

// out of range

3722

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3723

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

Jeff Johnson

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

[diff] [blame]

3724

goto done;

3725

}

3726

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

3727

break;

3728

3729

case WLAN_PARAM_String:

3730

len_value_str = strlen(value_str);

3731

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

{

// too big

hddLog(LOGE,

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

3736

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3737

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3738

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

3739

goto done;

3740

}

3741

// copy string plus NUL

3742

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

3743

break;

3744

3745

case WLAN_PARAM_MacAddr:

3746

len_value_str = strlen(value_str);

3747

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3752

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3753

__func__, value_str,

Jeff Johnson