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

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

[diff] [blame]

2402

#endif

2403

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

2404

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

2405

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

2406

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

2407

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

2408

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

2409

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

2410

2411

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

2412

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

2413

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

2414

#ifdef WLAN_BTAMP_FEATURE

2415

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

2416

#endif //WLAN_BTAMP_FEATURE

2417

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

2418

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

2419

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

2420

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

2421

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

2422

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

2423

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

2424

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

2425

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

2426

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

2427

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

2428

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

2429

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

Jeff Johnson

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

[diff] [blame]

2430

#ifdef WLAN_FEATURE_11AC

2431

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

2432

#endif

2433

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

2434

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

2435

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]

2436

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]

2437

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]

2438

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

2443

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2444

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

2445

{

2446

unsigned int idx;

2447

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2448

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

2449

v_U32_t value;

2450

char valueStr[CFG_VALUE_MAX_LEN];

2451

char configStr[CFG_ENTRY_MAX_LEN];

2452

char *fmt;

2453

void *pField;

2454

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2459

*pCur = '\0';

2460

2461

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

2462

{

2463

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

2464

2465

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

2466

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2467

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2468

{

2469

value = 0;

2470

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

2471

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

2484

}

2485

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2486

{

2487

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

2488

}

2489

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2490

{

2491

pMacAddr = (v_MACADDR_t *) pField;

2492

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2493

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

2504

}

2505

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2510

"*" : "");

2511

2512

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

2513

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

2514

#ifdef RETURN_IN_BUFFER

2515

if (curlen <= buflen)

2516

{

2517

// copy string + '\0'

2518

memcpy(pCur, configStr, curlen+1);

2519

2520

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2527

return VOS_STATUS_E_RESOURCES;

2528

}

2529

#else

2530

printk(KERN_CRIT "%s", configStr);

2531

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2536

// notify application that output is in system log

2537

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

2538

#endif // RETURN_IN_BUFFER

2539

2540

return VOS_STATUS_SUCCESS;

2541

}

2542

2543

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

2544

char *name, char** value)

2545

{

2546

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2547

unsigned long i;

2548

2549

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

2550

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

2551

*value = iniTable[i].value;

2552

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

2553

WLAN_INI_FILE, name, *value);

2554

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2562

{

2563

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

2564

return c-'0';

2565

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

2566

return c-'a'+10;

2567

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)

2575

{

2576

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2577

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2578

unsigned int idx;

2579

void *pField;

2580

char *value_str = NULL;

2581

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2586

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2587

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

2588

v_U32_t cbOutString;

2589

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2590

int rv;

Jeff Johnson

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

[diff] [blame]

2591

2592

// sanity test

2593

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2594

{

2595

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]

2596

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2597

}

2598

2599

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

2600

{

2601

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

2602

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

2603

2604

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

2605

2606

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

2607

{

2608

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

2609

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2610

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2611

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2616

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2617

{

2618

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

2619

// If not, use the default value.

2620

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2621

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

2622

if (rv < 0) {

2623

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

2624

__func__, pRegEntry->RegName);

2625

value = pRegEntry->VarDefault;

2626

}

Jeff Johnson

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

[diff] [blame]

2627

}

2628

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2629

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

2630

if (rv < 0) {

2631

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

2632

__func__, pRegEntry->RegName);

2633

value = pRegEntry->VarDefault;

2634

}

Jeff Johnson

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

[diff] [blame]

2635

}

2636

else {

2637

value = pRegEntry->VarDefault;

2638

}

2639

2640

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

2641

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2642

{

2643

if ( value > pRegEntry->VarMax )

2644

{

2645

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2646

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

Jeff Johnson

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

[diff] [blame]

2647

value = pRegEntry->VarMax;

2648

}

2649

2650

if ( value < pRegEntry->VarMin )

2651

{

2652

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2653

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

Jeff Johnson

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

[diff] [blame]

2654

value = pRegEntry->VarMin;

2655

}

2656

}

2657

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

2658

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2659

{

2660

if ( value > pRegEntry->VarMax )

2661

{

2662

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]

2663

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

Jeff Johnson

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

[diff] [blame]

2664

value = pRegEntry->VarDefault;

2665

}

2666

2667

if ( value < pRegEntry->VarMin )

2668

{

2669

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]

2670

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

Jeff Johnson

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

[diff] [blame]

2671

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2676

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

2677

}

2678

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2679

{

2680

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

2681

// If not, use the default value.

2682

if (VOS_STATUS_SUCCESS == match_status)

2683

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2684

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

2685

if (rv < 0) {

2686

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

2687

__func__, pRegEntry->RegName);

2688

svalue = (v_S31_t)pRegEntry->VarDefault;

2689

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2694

}

2695

2696

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

2697

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2698

{

2699

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

2700

{

2701

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2702

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

Jeff Johnson

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

[diff] [blame]

2703

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

2704

svalue = (v_S31_t)pRegEntry->VarMax;

2705

}

2706

2707

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

2708

{

2709

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2710

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

Jeff Johnson

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

[diff] [blame]

2711

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

2712

svalue = (v_S31_t)pRegEntry->VarMin;

2713

}

2714

}

2715

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

2716

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2717

{

2718

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

2719

{

2720

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

2721

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2722

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2723

(int)pRegEntry->VarMax,

2724

(int)pRegEntry->VarDefault );

2725

svalue = (v_S31_t)pRegEntry->VarDefault;

2726

}

2727

2728

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

2729

{

2730

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

2731

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2732

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2733

(int)pRegEntry->VarMin,

2734

(int)pRegEntry->VarDefault);

2735

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2740

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

2741

}

2742

// Handle string parameters

2743

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2744

{

2745

#ifdef WLAN_CFG_DEBUG

2746

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

2747

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

2748

#endif

2749

2750

if ( match_status == VOS_STATUS_SUCCESS)

2751

{

2752

len_value_str = strlen(value_str);

2753

2754

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

2755

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]

2756

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

Jeff Johnson

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

[diff] [blame]

2757

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

2758

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

2759

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

}

else

{

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

2764

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

}

}

else

{

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

2770

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

2771

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

2772

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

2773

}

2774

}

2775

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2776

{

2777

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2778

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2779

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

Jeff Johnson

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

[diff] [blame]

2780

continue;

2781

}

2782

candidate = (char*)pRegEntry->VarDefault;

2783

if ( match_status == VOS_STATUS_SUCCESS) {

2784

len_value_str = strlen(value_str);

2785

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

2786

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]

2787

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

Jeff Johnson

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

[diff] [blame]

2788

}

2789

else

2790

candidate = value_str;

2791

}

2792

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

2793

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

2794

{

2795

((char*)pField)[i] =

2796

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

2802

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2803

}

2804

2805

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

2806

if( (match_status == VOS_STATUS_SUCCESS) &&

2807

(idx < MAX_CFG_INI_ITEMS) )

2808

{

2809

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

}

}

print_hdd_cfg(pHddCtx);

2814

2815

return( ret_status );

2816

}

2817

2818

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2823

return eCSR_DOT11_MODE_abg;

2824

case (eHDD_DOT11_MODE_11b):

2825

return eCSR_DOT11_MODE_11b;

2826

case (eHDD_DOT11_MODE_11g):

2827

return eCSR_DOT11_MODE_11g;

2828

default:

2829

case (eHDD_DOT11_MODE_11n):

2830

return eCSR_DOT11_MODE_11n;

2831

case (eHDD_DOT11_MODE_11g_ONLY):

2832

return eCSR_DOT11_MODE_11g_ONLY;

2833

case (eHDD_DOT11_MODE_11n_ONLY):

2834

return eCSR_DOT11_MODE_11n_ONLY;

2835

case (eHDD_DOT11_MODE_11b_ONLY):

2836

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2837

#ifdef WLAN_FEATURE_11AC

2838

case (eHDD_DOT11_MODE_11ac_ONLY):

2839

return eCSR_DOT11_MODE_11ac_ONLY;

2840

case (eHDD_DOT11_MODE_11ac):

2841

return eCSR_DOT11_MODE_11ac;

2842

#endif

Jeff Johnson

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

[diff] [blame]

2843

case (eHDD_DOT11_MODE_AUTO):

2844

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2850

{

2851

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2852

tSmeBtcConfig btcParams;

2853

2854

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2855

2856

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2857

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2858

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2859

Jeff Johnson

32d95a3

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

[diff] [blame]

2860

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2861

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2862

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2863

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2864

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2865

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2866

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2867

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2868

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2869

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2870

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2871

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2872

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2873

Jeff Johnson

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

[diff] [blame]

2874

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2875

}

2876

2877

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

2878

{

2879

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2880

2881

tPmcBmpsConfigParams bmpsParams;

2882

2883

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

2884

2885

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

2886

{

2887

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

2888

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2889

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2890

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2891

}

2892

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

2893

{

2894

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

2895

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2896

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2897

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2898

}

2899

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

2900

{

2901

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

2902

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2903

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2904

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2905

}

2906

2907

if (pConfig->fIsImpsEnabled)

2908

{

2909

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2914

}

2915

Madan Mohan Koyyalamudi

69b3418

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

[diff] [blame]

2916

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

2917

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

2918

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

2919

Jeff Johnson

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

[diff] [blame]

2920

if (pConfig->fIsBmpsEnabled)

2921

{

2922

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2927

}

2928

2929

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2930

2931

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

2932

{

2933

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

2934

}

2935

2936

if(pConfig->fIsAutoBmpsTimerEnabled)

2937

{

2938

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2944

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 )

2949

{

2950

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2954

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

2955

{

2956

int val;

2957

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

2958

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

2959

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

2960

{

2961

intArray[*len] = (tANI_U8) val;

2962

*len += 1;

2963

}

2964

s = strpbrk( s, "," );

2965

if( s )

2966

s++;

2967

}

Jeff Johnson

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

[diff] [blame]

2968

2969

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2976

{

2977

v_BOOL_t fStatus = TRUE;

Gopichand Nakkala

976e325

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

[diff] [blame]

2978

#ifdef WLAN_SOFTAP_VSTA_FEATURE

2979

tANI_U32 val;

2980

#endif

Jeff Johnson

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

[diff] [blame]

2981

2982

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2983

tSirMacHTCapabilityInfo htCapInfo;

2984

Jeff Johnson

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

[diff] [blame]

2985

2986

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2987

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

2988

{

2989

fStatus = FALSE;

2990

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

2991

}

2992

2993

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

2994

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2995

{

2996

fStatus = FALSE;

2997

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

2998

}

2999

3000

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

3001

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3002

{

3003

fStatus = FALSE;

3004

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

3005

}

3006

3007

if ( 0 != pConfig->Cfg1Id )

3008

{

3009

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

3010

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3011

{

3012

fStatus = FALSE;

3013

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

}

}

if ( 0 != pConfig->Cfg2Id )

3019

{

3020

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

3021

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3022

{

3023

fStatus = FALSE;

3024

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

}

}

if ( 0 != pConfig->Cfg3Id )

3029

{

3030

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

3031

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3032

{

3033

fStatus = FALSE;

3034

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

}

}

if ( 0 != pConfig->Cfg4Id )

3039

{

3040

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

3041

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3042

{

3043

fStatus = FALSE;

3044

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

}

}

if ( 0 != pConfig->Cfg5Id )

3049

{

3050

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

3051

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3052

{

3053

fStatus = FALSE;

3054

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

}

}

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

3059

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3060

{

3061

fStatus = FALSE;

3062

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

3063

}

3064

3065

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

3066

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3067

{

3068

fStatus = FALSE;

3069

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

3070

}

3071

3072

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

3073

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

3074

{

3075

fStatus = FALSE;

3076

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

3077

}

3078

3079

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

3080

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3081

{

3082

fStatus = FALSE;

3083

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

3084

}

3085

3086

if (pConfig->fIsAutoIbssBssid)

3087

{

3088

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

3089

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

3090

{

3091

fStatus = FALSE;

3092

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

}

}

else

{

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

3098

{

3099

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

3100

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

3101

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

3102

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

3103

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

3104

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

3105

{

3106

fStatus = FALSE;

3107

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,

3118

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3119

{

3120

fStatus = FALSE;

3121

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

3122

}

3123

3124

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

3125

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3126

{

3127

fStatus = FALSE;

3128

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

3129

}

3130

3131

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

3132

{

3133

fStatus = FALSE;

3134

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

3135

}

3136

3137

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

3138

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3139

{

3140

fStatus = FALSE;

3141

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

3142

}

3143

3144

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

3145

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3146

{

3147

fStatus = FALSE;

3148

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

3149

}

3150

Jeff Johnson

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

[diff] [blame]

3151

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

3152

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3153

{

3154

fStatus = FALSE;

3155

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

3156

}

3157

3158

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

3159

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3160

{

3161

fStatus = FALSE;

3162

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

3163

}

3164

3165

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

3166

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3167

{

3168

fStatus = FALSE;

3169

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

3170

}

3171

Gopichand Nakkala

98a98af

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

[diff] [blame]

3172

#ifdef FEATURE_WLAN_LFR

3173

if (pConfig->isFastRoamIniFeatureEnabled)

3174

{

3175

pConfig->fEnableFwRssiMonitoring = TRUE;

3176

}

3177

#endif

3178

#ifdef FEATURE_WLAN_CCX

3179

if (pConfig->isCcxIniFeatureEnabled)

3180

{

3181

pConfig->fEnableFwRssiMonitoring = TRUE;

3182

}

3183

#endif

Jeff Johnson

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

[diff] [blame]

3184

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

3185

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3186

{

3187

fStatus = FALSE;

3188

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

3189

}

3190

3191

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

3192

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3193

{

3194

fStatus = FALSE;

3195

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

3196

}

3197

3198

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

3199

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3200

{

3201

fStatus = FALSE;

3202

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

3203

}

3204

3205

#ifdef WLAN_SOFTAP_FEATURE

3206

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

3207

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3208

{

3209

fStatus = FALSE;

3210

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

3211

}

3212

3213

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

3214

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3215

{

3216

fStatus = FALSE;

3217

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

3218

}

3219

Jeff Johnson

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

[diff] [blame]

3220

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

3221

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3222

{

3223

fStatus = FALSE;

3224

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

3225

}

3226

3227

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

3228

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3229

{

3230

fStatus = FALSE;

3231

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

3236

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

3237

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3238

{

3239

fStatus = FALSE;

3240

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

3241

}

3242

3243

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

3244

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3245

{

3246

fStatus = FALSE;

3247

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

3248

}

3249

3250

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

3251

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3252

{

3253

fStatus = FALSE;

3254

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

3255

}

3256

3257

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

3258

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3259

#endif

3260

3261

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

3262

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3263

{

3264

fStatus = FALSE;

3265

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

3266

}

3267

3268

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

3269

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3270

{

3271

fStatus = FALSE;

3272

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

3273

}

3274

3275

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

3276

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3277

{

3278

fStatus = FALSE;

3279

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

3280

}

3281

3282

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

3283

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3284

{

3285

fStatus = FALSE;

3286

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

3287

}

3288

3289

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

3290

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3291

{

3292

fStatus = FALSE;

3293

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

3294

}

3295

3296

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

3297

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3298

{

3299

fStatus = FALSE;

3300

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

3301

}

3302

3303

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

3304

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3305

{

3306

fStatus = FALSE;

3307

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

3308

}

3309

3310

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

3311

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3312

{

3313

fStatus = FALSE;

3314

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

3315

}

3316

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

3317

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3318

{

3319

fStatus = FALSE;

3320

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

3321

}

3322

3323

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

3324

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3325

{

3326

fStatus = FALSE;

3327

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

3328

}

3329

3330

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

3331

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3332

{

3333

fStatus = FALSE;

3334

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

3335

}

3336

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3337

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

3338

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3339

{

3340

fStatus = FALSE;

3341

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

3342

}

3343

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

3344

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3345

{

3346

fStatus = FALSE;

3347

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

3348

}

3349

3350

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

3351

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3352

{

3353

fStatus = FALSE;

3354

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

3355

}

3356

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

3357

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3358

{

3359

fStatus = FALSE;

3360

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,

3365

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3366

{

3367

fStatus = FALSE;

3368

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

3369

}

3370

3371

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3372

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3373

==eHAL_STATUS_FAILURE)

3374

{

3375

fStatus = FALSE;

3376

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

3377

}

3378

3379

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3380

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3381

==eHAL_STATUS_FAILURE)

3382

{

3383

fStatus = FALSE;

3384

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

3385

}

3386

3387

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3388

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

3389

{

3390

fStatus = FALSE;

3391

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

3392

}

3393

Jeff Johnson

d13512a

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

[diff] [blame]

3394

3395

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

3396

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3397

{

3398

fStatus = FALSE;

3399

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

3400

}

3401

Jeff Johnson

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

[diff] [blame]

3402

#ifdef WLAN_FEATURE_11AC

3403

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

3404

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

3405

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

3406

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

3407

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3408

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3414

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

3415

3416

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3417

temp, NULL, eANI_BOOLEAN_FALSE)

3418

==eHAL_STATUS_FAILURE)

3419

{

3420

fStatus = FALSE;

3421

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

3422

}

3423

3424

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

3425

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

3426

3427

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3428

temp, NULL, eANI_BOOLEAN_FALSE)

3429

==eHAL_STATUS_FAILURE)

3430

{

3431

fStatus = FALSE;

3432

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

3433

}

3434

3435

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

3436

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

3437

3438

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3439

temp, NULL, eANI_BOOLEAN_FALSE)

3440

==eHAL_STATUS_FAILURE)

3441

{

3442

fStatus = FALSE;

3443

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]

3449

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

3450

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3451

{

3452

fStatus = FALSE;

3453

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

3454

}

3455

Pratik Bhalgat

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

[diff] [blame]

3456

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3457

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3458

==eHAL_STATUS_FAILURE)

3459

{

3460

fStatus = FALSE;

3461

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

3462

}

3463

3464

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

3465

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3466

3467

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3468

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

3469

==eHAL_STATUS_FAILURE)

3470

{

3471

fStatus = FALSE;

3472

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

3473

}

3474

3475

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3476

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3477

==eHAL_STATUS_FAILURE)

3478

{

3479

fStatus = FALSE;

3480

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

3481

}

Gopichand Nakkala

976e325

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

[diff] [blame]

3482

3483

#ifdef WLAN_SOFTAP_VSTA_FEATURE

3484

if(pConfig->fEnableVSTASupport)

3485

{

3486

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

3487

if( val <= WNI_CFG_ASSOC_STA_LIMIT_STADEF)

3488

val = WNI_CFG_ASSOC_STA_LIMIT_STAMAX;

}

else

{

val = WNI_CFG_ASSOC_STA_LIMIT_STADEF;

3493

}

3494

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

3495

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3496

{

3497

fStatus = FALSE;

3498

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

3499

}

3500

#endif

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3501

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3502

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3503

==eHAL_STATUS_FAILURE)

3504

{

3505

fStatus = FALSE;

3506

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

3507

}

Pratik Bhalgat

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

[diff] [blame]

3508

Madan Mohan Koyyalamudi

01cba04

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

[diff] [blame]

3509

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

3510

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3511

{

3512

fStatus = FALSE;

3513

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

3514

}

Leela V Kiran Kumar Reddy Chirala

b1f7d34

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

[diff] [blame]

3515

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

3516

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3517

{

3518

fStatus = FALSE;

3519

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

3520

}

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3526

3527

\brief hdd_init_set_sme_config() -

3528

3529

This function initializes the sme configuration parameters

3530

3531

\param - pHddCtx - Pointer to the HDD Adapter.

3532

3533

\return - 0 for success, non zero for failure

3534

3535

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

3536

3537

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3538

{

3539

VOS_STATUS status = VOS_STATUS_SUCCESS;

3540

eHalStatus halStatus;

3541

tSmeConfigParams smeConfig;

3542

3543

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3544

3545

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3546

3547

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3548

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

3549

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

3550

3551

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3552

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3553

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

Jeff Johnson

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

[diff] [blame]

3554

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3555

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3556

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3557

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3558

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3559

3560

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

3561

3562

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3563

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3564

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3565

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3566

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3567

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3568

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3569

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3570

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3571

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3572

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3573

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3574

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3575

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3576

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3577

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3578

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3579

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3580

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3581

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3582

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3583

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3584

#ifdef WLAN_AP_STA_CONCURRENCY

3585

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3586

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3587

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3588

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3589

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

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

[diff] [blame]

3590

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3591

#endif

Jeff Johnson

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

[diff] [blame]

3592

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3593

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3594

3595

#if defined WLAN_FEATURE_VOWIFI

3596

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3597

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3598

#endif

3599

//Remaining config params not obtained from registry

3600

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3601

#ifdef WLAN_FEATURE_11AC

3602

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

Shailender Karmuchi

08f87c2

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

[diff] [blame]

3603

smeConfig.csrConfig.enableTxBF = pConfig->enableTxBF;

Shailender Karmuchi

cc3fe44

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

[diff] [blame]

3604

smeConfig.csrConfig.txBFCsnValue = pConfig->txBFCsnValue;

Jeff Johnson

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

[diff] [blame]

3605

#endif

Jeff Johnson

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

[diff] [blame]

3606

smeConfig.csrConfig.AdHocChannel5G = 44;

3607

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3608

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3609

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

Madan Mohan Koyyalamudi

8db1c94

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

[diff] [blame]

3610

if (pConfig->nBandCapability == eCSR_BAND_24)

3611

{

3612

smeConfig.csrConfig.Is11hSupportEnabled = 0;

3613

} else {

3614

smeConfig.csrConfig.Is11hSupportEnabled = pConfig->Is11hSupportEnabled;

3615

}

Jeff Johnson

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

[diff] [blame]

3616

smeConfig.csrConfig.cbChoice = 0;

3617

smeConfig.csrConfig.bgScanInterval = 0;

3618

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3619

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3620

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3621

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3622

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3623

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

3624

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3625

#endif

Jeff Johnson

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

[diff] [blame]

3626

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3627

Jeff Johnson

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

[diff] [blame]

3628

//FIXME 11d config is hardcoded

3629

#ifdef WLAN_SOFTAP_FEATURE

3630

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3631

#endif

3632

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

3633

3634

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

3635

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

3636

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

3637

3638

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3643

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

3644

3645

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

3646

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

3647

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3648

}

3649

#endif

3650

hdd_set_power_save_config(pHddCtx, &smeConfig);

3651

hdd_set_btc_config(pHddCtx);

3652

3653

#ifdef WLAN_FEATURE_VOWIFI_11R

3654

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

3655

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3656

#ifdef FEATURE_WLAN_LFR

3657

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3658

if( pConfig->isFastRoamIniFeatureEnabled )

3659

{

3660

pConfig->isFastTransitionEnabled = TRUE;

3661

}

Jeff Johnson

04dd8a8

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

[diff] [blame]

3662

#endif

Jeff Johnson

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

[diff] [blame]

3663

#ifdef FEATURE_WLAN_CCX

3664

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

Gopichand Nakkala

98a98af

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

[diff] [blame]

3665

if( pConfig->isCcxIniFeatureEnabled )

3666

{

3667

pConfig->isFastTransitionEnabled = TRUE;

3668

}

Jeff Johnson

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

[diff] [blame]

3669

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3670

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

3671

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3672

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3673

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3674

#endif

3675

3676

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3677

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

3678

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

3679

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

3680

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

3681

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

3682

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

3683

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

Srinivas Girigowda

de69741

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

[diff] [blame^]

3684

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

Jeff Johnson

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

[diff] [blame]

3685

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3686

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3687

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3688

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3689

#endif

3690

3691

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3692

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3693

3694

//Enable/Disable MCC

3695

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3696

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3697

Sandeep Puligilla

2b6dc63

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

[diff] [blame]

3698

//Scan Results Aging Time out value

3699

smeConfig.csrConfig.scanCfgAgingTime = pConfig->scanAgingTimeout;

3700

Gopichand Nakkala

b2d2c31

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

[diff] [blame]

3701

smeConfig.csrConfig.enableTxLdpc = pConfig->enableTxLdpc;

3702

Jeff Johnson

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

[diff] [blame]

3703

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

3704

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3705

{

3706

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3715

3716

\brief hdd_execute_config_command() -

3717

3718

This function executes an arbitrary configuration set command

3719

3720

\param - pHddCtx - Pointer to the HDD Adapter.

3721

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

3722

3723

3724

\return - 0 for success, non zero for failure

3725

3726

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

3727

3728

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3729

{

3730

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

3731

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;

3740

unsigned int idx;

3741

unsigned int i;

3742

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3743

int rv;

Jeff Johnson

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

[diff] [blame]

3744

3745

// assume failure until proven otherwise

3746

vstatus = VOS_STATUS_E_FAILURE;

3747

3748

// clone the command so that we can manipulate it

3749

clone = kstrdup(command, GFP_ATOMIC);

3750

if (NULL == clone)

3751

{

3752

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3753

__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

3758

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

3759

pCmd = clone;

3760

3761

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

3767

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3772

name = pCmd;

3773

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]

3781

__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

3791

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3792

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3797

if ('\0' == *value_str)

3798

{

3799

// did not find a value

3800

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3801

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3806

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

3807

{

3808

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

{

// found a match

break;

}

}

if (tableSize == idx)

3815

{

3816

// did not match the name

3817

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3818

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3823

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

3824

{

3825

// does not support dynamic configuration

3826

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3827

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

3832

3833

switch (pRegEntry->RegType)

3834

{

3835

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3836

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

3837

if (rv < 0)

3838

goto done;

Jeff Johnson

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

[diff] [blame]

3839

if (value < pRegEntry->VarMin)

3840

{

3841

// out of range

3842

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3843

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3844

goto done;

3845

}

3846

if (value > pRegEntry->VarMax)

3847

{

3848

// out of range

3849

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3850

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3851

goto done;

3852

}

3853

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

3854

break;

3855

3856

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3857

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

3858

if (rv < 0)

3859

goto done;

Jeff Johnson

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

[diff] [blame]

3860

if (value < pRegEntry->VarMin)

3861

{

3862

// out of range

3863

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3864

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3865

goto done;

3866

}

3867

if (value > pRegEntry->VarMax)

3868

{

3869

// out of range

3870

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3871

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3872

goto done;

3873

}

3874

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

3875

break;

3876

3877

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3878

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

3879

if (rv < 0)

3880

goto done;

Jeff Johnson

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

[diff] [blame]

3881

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

3882

{

3883

// out of range

3884

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3885

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

Jeff Johnson

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

[diff] [blame]

3886

goto done;

3887

}

3888

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

3889

{

3890

// out of range

3891

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3892

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

Jeff Johnson

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

[diff] [blame]

3893

goto done;

3894

}

3895

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

3896

break;

3897

3898

case WLAN_PARAM_String:

3899

len_value_str = strlen(value_str);

3900

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

{

// too big

hddLog(LOGE,

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

3905

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3906

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3907

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

3908

goto done;

3909

}

3910

// copy string plus NUL

3911

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

3912

break;

3913

3914

case WLAN_PARAM_MacAddr:

3915

len_value_str = strlen(value_str);

3916

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3921

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3922

__func__, value_str,

Jeff Johnson