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

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

[diff] [blame]

2145

#ifdef WLAN_FEATURE_11AC

2146

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

2147

#endif

2148

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

2149

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

2150

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]

2151

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]

2152

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]

2153

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

2158

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2159

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

2160

{

2161

unsigned int idx;

2162

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2163

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

2164

v_U32_t value;

2165

char valueStr[CFG_VALUE_MAX_LEN];

2166

char configStr[CFG_ENTRY_MAX_LEN];

2167

char *fmt;

2168

void *pField;

2169

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2174

*pCur = '\0';

2175

2176

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

2177

{

2178

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

2179

2180

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

2181

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2182

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2183

{

2184

value = 0;

2185

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

2186

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

2199

}

2200

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2201

{

2202

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

2203

}

2204

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2205

{

2206

pMacAddr = (v_MACADDR_t *) pField;

2207

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2208

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

2219

}

2220

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2225

"*" : "");

2226

2227

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

2228

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

2229

#ifdef RETURN_IN_BUFFER

2230

if (curlen <= buflen)

2231

{

2232

// copy string + '\0'

2233

memcpy(pCur, configStr, curlen+1);

2234

2235

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2242

return VOS_STATUS_E_RESOURCES;

2243

}

2244

#else

2245

printk(KERN_CRIT "%s", configStr);

2246

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2251

// notify application that output is in system log

2252

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

2253

#endif // RETURN_IN_BUFFER

2254

2255

return VOS_STATUS_SUCCESS;

2256

}

2257

2258

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

2259

char *name, char** value)

2260

{

2261

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2262

unsigned long i;

2263

2264

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

2265

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

2266

*value = iniTable[i].value;

2267

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

2268

WLAN_INI_FILE, name, *value);

2269

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2277

{

2278

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

2279

return c-'0';

2280

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

2281

return c-'a'+10;

2282

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)

2290

{

2291

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2292

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2293

unsigned int idx;

2294

void *pField;

2295

char *value_str = NULL;

2296

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2301

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2302

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

2303

v_U32_t cbOutString;

2304

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2305

int rv;

Jeff Johnson

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

[diff] [blame]

2306

2307

// sanity test

2308

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2309

{

2310

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]

2311

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2312

}

2313

2314

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

2315

{

2316

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

2317

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

2318

2319

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

2320

2321

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

2322

{

2323

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

2324

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2325

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2326

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2331

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2332

{

2333

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

2334

// If not, use the default value.

2335

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2336

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

2337

if (rv < 0) {

2338

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

2339

__func__, pRegEntry->RegName);

2340

value = pRegEntry->VarDefault;

2341

}

Jeff Johnson

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

[diff] [blame]

2342

}

2343

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2344

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

2345

if (rv < 0) {

2346

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

2347

__func__, pRegEntry->RegName);

2348

value = pRegEntry->VarDefault;

2349

}

Jeff Johnson

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

[diff] [blame]

2350

}

2351

else {

2352

value = pRegEntry->VarDefault;

2353

}

2354

2355

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

2356

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2357

{

2358

if ( value > pRegEntry->VarMax )

2359

{

2360

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2361

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

Jeff Johnson

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

[diff] [blame]

2362

value = pRegEntry->VarMax;

2363

}

2364

2365

if ( value < pRegEntry->VarMin )

2366

{

2367

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2368

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

Jeff Johnson

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

[diff] [blame]

2369

value = pRegEntry->VarMin;

2370

}

2371

}

2372

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

2373

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2374

{

2375

if ( value > pRegEntry->VarMax )

2376

{

2377

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]

2378

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

Jeff Johnson

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

[diff] [blame]

2379

value = pRegEntry->VarDefault;

2380

}

2381

2382

if ( value < pRegEntry->VarMin )

2383

{

2384

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]

2385

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

Jeff Johnson

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

[diff] [blame]

2386

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2391

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

2392

}

2393

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2394

{

2395

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

2396

// If not, use the default value.

2397

if (VOS_STATUS_SUCCESS == match_status)

2398

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2399

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

2400

if (rv < 0) {

2401

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

2402

__func__, pRegEntry->RegName);

2403

svalue = (v_S31_t)pRegEntry->VarDefault;

2404

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2409

}

2410

2411

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

2412

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2413

{

2414

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

2415

{

2416

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2417

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

Jeff Johnson

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

[diff] [blame]

2418

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

2419

svalue = (v_S31_t)pRegEntry->VarMax;

2420

}

2421

2422

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

2423

{

2424

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2425

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

Jeff Johnson

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

[diff] [blame]

2426

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

2427

svalue = (v_S31_t)pRegEntry->VarMin;

2428

}

2429

}

2430

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

2431

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2432

{

2433

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

2434

{

2435

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

2436

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2437

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2438

(int)pRegEntry->VarMax,

2439

(int)pRegEntry->VarDefault );

2440

svalue = (v_S31_t)pRegEntry->VarDefault;

2441

}

2442

2443

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

2444

{

2445

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

2446

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2447

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2448

(int)pRegEntry->VarMin,

2449

(int)pRegEntry->VarDefault);

2450

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2455

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

2456

}

2457

// Handle string parameters

2458

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2459

{

2460

#ifdef WLAN_CFG_DEBUG

2461

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

2462

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

2463

#endif

2464

2465

if ( match_status == VOS_STATUS_SUCCESS)

2466

{

2467

len_value_str = strlen(value_str);

2468

2469

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

2470

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]

2471

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

Jeff Johnson

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

[diff] [blame]

2472

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

2473

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

2474

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

}

else

{

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

2479

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

}

}

else

{

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

2485

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

2486

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

2487

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

2488

}

2489

}

2490

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2491

{

2492

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2493

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2494

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

Jeff Johnson

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

[diff] [blame]

2495

continue;

2496

}

2497

candidate = (char*)pRegEntry->VarDefault;

2498

if ( match_status == VOS_STATUS_SUCCESS) {

2499

len_value_str = strlen(value_str);

2500

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

2501

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]

2502

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

Jeff Johnson

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

[diff] [blame]

2503

}

2504

else

2505

candidate = value_str;

2506

}

2507

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

2508

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

2509

{

2510

((char*)pField)[i] =

2511

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

2517

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2518

}

2519

2520

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

2521

if( (match_status == VOS_STATUS_SUCCESS) &&

2522

(idx < MAX_CFG_INI_ITEMS) )

2523

{

2524

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

}

}

print_hdd_cfg(pHddCtx);

2529

2530

return( ret_status );

2531

}

2532

2533

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2538

return eCSR_DOT11_MODE_abg;

2539

case (eHDD_DOT11_MODE_11b):

2540

return eCSR_DOT11_MODE_11b;

2541

case (eHDD_DOT11_MODE_11g):

2542

return eCSR_DOT11_MODE_11g;

2543

default:

2544

case (eHDD_DOT11_MODE_11n):

2545

return eCSR_DOT11_MODE_11n;

2546

case (eHDD_DOT11_MODE_11g_ONLY):

2547

return eCSR_DOT11_MODE_11g_ONLY;

2548

case (eHDD_DOT11_MODE_11n_ONLY):

2549

return eCSR_DOT11_MODE_11n_ONLY;

2550

case (eHDD_DOT11_MODE_11b_ONLY):

2551

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2552

#ifdef WLAN_FEATURE_11AC

2553

case (eHDD_DOT11_MODE_11ac_ONLY):

2554

return eCSR_DOT11_MODE_11ac_ONLY;

2555

case (eHDD_DOT11_MODE_11ac):

2556

return eCSR_DOT11_MODE_11ac;

2557

#endif

Jeff Johnson

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

[diff] [blame]

2558

case (eHDD_DOT11_MODE_AUTO):

2559

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2565

{

2566

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2567

tSmeBtcConfig btcParams;

2568

2569

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2570

2571

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2572

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2573

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2574

Jeff Johnson

32d95a3

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

[diff] [blame]

2575

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2576

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2577

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2578

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2579

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2580

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2581

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2582

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2583

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2584

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2585

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2586

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2587

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2588

Jeff Johnson

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

[diff] [blame]

2589

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2590

}

2591

2592

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

2593

{

2594

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2595

2596

tPmcBmpsConfigParams bmpsParams;

2597

2598

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

2599

2600

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

2601

{

2602

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

2603

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2604

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2605

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2606

}

2607

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

2608

{

2609

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

2610

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2611

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2612

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2613

}

2614

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

2615

{

2616

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

2617

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2618

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2619

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2620

}

2621

2622

if (pConfig->fIsImpsEnabled)

2623

{

2624

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2629

}

2630

2631

if (pConfig->fIsBmpsEnabled)

2632

{

2633

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2638

}

2639

2640

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2641

2642

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

2643

{

2644

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

2645

}

2646

2647

if(pConfig->fIsAutoBmpsTimerEnabled)

2648

{

2649

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2655

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 )

2660

{

2661

return VOS_STATUS_E_INVAL;

}

*len = 0;

Jeff Johnson

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

[diff] [blame]

2665

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

2666

{

2667

int val;

2668

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

2669

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

2670

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

2671

{

2672

intArray[*len] = (tANI_U8) val;

2673

*len += 1;

2674

}

2675

s = strpbrk( s, "," );

2676

if( s )

2677

s++;

2678

}

Jeff Johnson

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

[diff] [blame]

2679

2680

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2687

{

2688

v_BOOL_t fStatus = TRUE;

2689

2690

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

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

[diff] [blame]

2691

tSirMacHTCapabilityInfo htCapInfo;

2692

Jeff Johnson

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

[diff] [blame]

2693

2694

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2695

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

2696

{

2697

fStatus = FALSE;

2698

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

2699

}

2700

2701

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

2702

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2703

{

2704

fStatus = FALSE;

2705

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

2706

}

2707

2708

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

2709

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2710

{

2711

fStatus = FALSE;

2712

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

2713

}

2714

2715

if ( 0 != pConfig->Cfg1Id )

2716

{

2717

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

2718

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2719

{

2720

fStatus = FALSE;

2721

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

}

}

if ( 0 != pConfig->Cfg2Id )

2727

{

2728

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

2729

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2730

{

2731

fStatus = FALSE;

2732

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

}

}

if ( 0 != pConfig->Cfg3Id )

2737

{

2738

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

2739

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2740

{

2741

fStatus = FALSE;

2742

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

}

}

if ( 0 != pConfig->Cfg4Id )

2747

{

2748

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

2749

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2750

{

2751

fStatus = FALSE;

2752

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

}

}

if ( 0 != pConfig->Cfg5Id )

2757

{

2758

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

2759

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2760

{

2761

fStatus = FALSE;

2762

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

}

}

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

2767

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2768

{

2769

fStatus = FALSE;

2770

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

2771

}

2772

2773

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

2774

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2775

{

2776

fStatus = FALSE;

2777

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

2778

}

2779

2780

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2781

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

2782

{

2783

fStatus = FALSE;

2784

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

2785

}

2786

2787

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

2788

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2789

{

2790

fStatus = FALSE;

2791

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

2792

}

2793

2794

if (pConfig->fIsAutoIbssBssid)

2795

{

2796

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

2797

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

2798

{

2799

fStatus = FALSE;

2800

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

}

}

else

{

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

2806

{

2807

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2808

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

2809

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

2810

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

2811

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

2812

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

2813

{

2814

fStatus = FALSE;

2815

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,

2826

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2827

{

2828

fStatus = FALSE;

2829

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

2830

}

2831

2832

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

2833

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2834

{

2835

fStatus = FALSE;

2836

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

2837

}

2838

2839

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

2840

{

2841

fStatus = FALSE;

2842

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

2843

}

2844

2845

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

2846

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2847

{

2848

fStatus = FALSE;

2849

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

2850

}

2851

2852

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

2853

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2854

{

2855

fStatus = FALSE;

2856

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

2857

}

2858

Jeff Johnson

04dd8a8

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

[diff] [blame]

2859

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

2860

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

2861

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2862

{

2863

fStatus = FALSE;

2864

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

}

#endif

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

2869

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2870

{

2871

fStatus = FALSE;

2872

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

2873

}

2874

2875

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

2876

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2877

{

2878

fStatus = FALSE;

2879

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

2880

}

2881

2882

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

2883

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2884

{

2885

fStatus = FALSE;

2886

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

2887

}

2888

2889

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

2890

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2891

{

2892

fStatus = FALSE;

2893

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

2894

}

2895

2896

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

2897

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2898

{

2899

fStatus = FALSE;

2900

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

2901

}

2902

2903

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

2904

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2905

{

2906

fStatus = FALSE;

2907

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

2908

}

2909

2910

#ifdef WLAN_SOFTAP_FEATURE

2911

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

2912

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2913

{

2914

fStatus = FALSE;

2915

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

2916

}

2917

2918

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

2919

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2920

{

2921

fStatus = FALSE;

2922

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

2923

}

2924

Jeff Johnson

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

[diff] [blame]

2925

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

2926

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2927

{

2928

fStatus = FALSE;

2929

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

2930

}

2931

2932

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

2933

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2934

{

2935

fStatus = FALSE;

2936

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

2941

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

2942

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2943

{

2944

fStatus = FALSE;

2945

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

2946

}

2947

2948

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

2949

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2950

{

2951

fStatus = FALSE;

2952

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

2953

}

2954

2955

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

2956

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2957

{

2958

fStatus = FALSE;

2959

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

2960

}

2961

2962

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

2963

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2964

#endif

2965

2966

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

2967

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2968

{

2969

fStatus = FALSE;

2970

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

2971

}

2972

2973

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

2974

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2975

{

2976

fStatus = FALSE;

2977

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

2978

}

2979

2980

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

2981

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2982

{

2983

fStatus = FALSE;

2984

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

2985

}

2986

2987

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

2988

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2989

{

2990

fStatus = FALSE;

2991

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

2992

}

2993

2994

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

2995

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2996

{

2997

fStatus = FALSE;

2998

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

2999

}

3000

3001

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

3002

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3003

{

3004

fStatus = FALSE;

3005

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

3006

}

3007

3008

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

3009

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3010

{

3011

fStatus = FALSE;

3012

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

3013

}

3014

3015

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

3016

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3017

{

3018

fStatus = FALSE;

3019

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

3020

}

3021

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

3022

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3023

{

3024

fStatus = FALSE;

3025

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

3026

}

3027

3028

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

3029

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3030

{

3031

fStatus = FALSE;

3032

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

3033

}

3034

3035

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

3036

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3037

{

3038

fStatus = FALSE;

3039

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

3040

}

3041

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3042

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

3043

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3044

{

3045

fStatus = FALSE;

3046

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

3047

}

3048

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

3049

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3050

{

3051

fStatus = FALSE;

3052

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

3053

}

3054

3055

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

3056

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3057

{

3058

fStatus = FALSE;

3059

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

3060

}

3061

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

3062

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3063

{

3064

fStatus = FALSE;

3065

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,

3070

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3071

{

3072

fStatus = FALSE;

3073

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

3074

}

3075

3076

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3077

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3078

==eHAL_STATUS_FAILURE)

3079

{

3080

fStatus = FALSE;

3081

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

3082

}

3083

3084

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3085

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3086

==eHAL_STATUS_FAILURE)

3087

{

3088

fStatus = FALSE;

3089

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

3090

}

3091

3092

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3093

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

3094

{

3095

fStatus = FALSE;

3096

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

3097

}

3098

Jeff Johnson

d13512a

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

[diff] [blame]

3099

3100

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

3101

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3102

{

3103

fStatus = FALSE;

3104

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

3105

}

3106

Jeff Johnson

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

[diff] [blame]

3107

#ifdef WLAN_FEATURE_11AC

3108

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

3109

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

3110

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

3111

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

3112

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3113

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3119

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

3120

3121

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3122

temp, NULL, eANI_BOOLEAN_FALSE)

3123

==eHAL_STATUS_FAILURE)

3124

{

3125

fStatus = FALSE;

3126

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

3127

}

3128

3129

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

3130

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

3131

3132

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3133

temp, NULL, eANI_BOOLEAN_FALSE)

3134

==eHAL_STATUS_FAILURE)

3135

{

3136

fStatus = FALSE;

3137

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

3138

}

3139

3140

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

3141

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

3142

3143

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3144

temp, NULL, eANI_BOOLEAN_FALSE)

3145

==eHAL_STATUS_FAILURE)

3146

{

3147

fStatus = FALSE;

3148

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]

3154

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

3155

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3156

{

3157

fStatus = FALSE;

3158

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

3159

}

3160

Pratik Bhalgat

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

[diff] [blame]

3161

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3162

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3163

==eHAL_STATUS_FAILURE)

3164

{

3165

fStatus = FALSE;

3166

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

3167

}

3168

3169

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

3170

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3171

3172

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3173

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

3174

==eHAL_STATUS_FAILURE)

3175

{

3176

fStatus = FALSE;

3177

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

3178

}

3179

3180

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3181

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3182

==eHAL_STATUS_FAILURE)

3183

{

3184

fStatus = FALSE;

3185

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

3186

}

Madan Mohan Koyyalamudi

0d40e66

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

[diff] [blame]

3187

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION,

3188

pConfig->enableLpwrImgTransition, NULL, eANI_BOOLEAN_FALSE)

3189

==eHAL_STATUS_FAILURE)

3190

{

3191

fStatus = FALSE;

3192

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

3193

}

Pratik Bhalgat

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

[diff] [blame]

3194

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3200

3201

\brief hdd_init_set_sme_config() -

3202

3203

This function initializes the sme configuration parameters

3204

3205

\param - pHddCtx - Pointer to the HDD Adapter.

3206

3207

\return - 0 for success, non zero for failure

3208

3209

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

3210

3211

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3212

{

3213

VOS_STATUS status = VOS_STATUS_SUCCESS;

3214

eHalStatus halStatus;

3215

tSmeConfigParams smeConfig;

3216

3217

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3218

3219

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3220

3221

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3222

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

3223

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

3224

3225

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3226

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3227

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

Jeff Johnson

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

[diff] [blame]

3228

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3229

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3230

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3231

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3232

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3233

3234

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

3235

3236

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3237

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3238

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3239

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3240

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3241

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3242

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3243

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3244

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3245

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3246

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3247

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3248

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3249

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3250

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3251

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3252

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3253

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3254

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3255

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3256

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3257

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3258

#ifdef WLAN_AP_STA_CONCURRENCY

3259

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3260

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3261

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3262

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3263

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

Vinay Malekal

05fdc81

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

[diff] [blame]

3264

smeConfig.csrConfig.nNumChanCombinedConc = pConfig->nNumChanCombinedConc;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3265

#endif

Jeff Johnson

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

[diff] [blame]

3266

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3267

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3268

3269

#if defined WLAN_FEATURE_VOWIFI

3270

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3271

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3272

#endif

3273

//Remaining config params not obtained from registry

3274

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3275

#ifdef WLAN_FEATURE_11AC

3276

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3277

#endif

Jeff Johnson

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

[diff] [blame]

3278

smeConfig.csrConfig.AdHocChannel5G = 44;

3279

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3280

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3281

smeConfig.csrConfig.Is11hSupportEnabled = 1;

Jeff Johnson

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

[diff] [blame]

3282

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

3283

smeConfig.csrConfig.cbChoice = 0;

3284

smeConfig.csrConfig.bgScanInterval = 0;

3285

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3286

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3287

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3288

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3289

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3290

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

3291

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3292

#endif

Jeff Johnson

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

[diff] [blame]

3293

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3294

Jeff Johnson

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

[diff] [blame]

3295

//FIXME 11d config is hardcoded

3296

#ifdef WLAN_SOFTAP_FEATURE

3297

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3298

#endif

3299

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

3300

3301

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

3302

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

3303

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

3304

3305

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3310

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

3311

3312

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

3313

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

3314

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3315

}

3316

#endif

3317

hdd_set_power_save_config(pHddCtx, &smeConfig);

3318

hdd_set_btc_config(pHddCtx);

3319

3320

#ifdef WLAN_FEATURE_VOWIFI_11R

3321

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

3322

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3323

#ifdef FEATURE_WLAN_LFR

3324

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

3325

#endif

Jeff Johnson

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

[diff] [blame]

3326

#ifdef FEATURE_WLAN_CCX

3327

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

3328

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3329

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

3330

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3331

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3332

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3333

#endif

3334

3335

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3336

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

3337

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

3338

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

3339

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

3340

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

3341

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

3342

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

3343

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3344

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3345

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3346

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3347

#endif

3348

3349

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3350

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3351

3352

//Enable/Disable MCC

3353

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3354

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3355

3356

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

3357

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3358

{

3359

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3368

3369

\brief hdd_execute_config_command() -

3370

3371

This function executes an arbitrary configuration set command

3372

3373

\param - pHddCtx - Pointer to the HDD Adapter.

3374

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

3375

3376

3377

\return - 0 for success, non zero for failure

3378

3379

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

3380

3381

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3382

{

3383

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

3384

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;

3393

unsigned int idx;

3394

unsigned int i;

3395

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3396

int rv;

Jeff Johnson

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

[diff] [blame]

3397

3398

// assume failure until proven otherwise

3399

vstatus = VOS_STATUS_E_FAILURE;

3400

3401

// clone the command so that we can manipulate it

3402

clone = kstrdup(command, GFP_ATOMIC);

3403

if (NULL == clone)

3404

{

3405

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3406

__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

3411

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

3412

pCmd = clone;

3413

3414

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

3420

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3425

name = pCmd;

3426

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]

3434

__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

3444

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3445

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3450

if ('\0' == *value_str)

3451

{

3452

// did not find a value

3453

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3454

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3459

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

3460

{

3461

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

{

// found a match

break;

}

}

if (tableSize == idx)

3468

{

3469

// did not match the name

3470

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3471

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3476

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

3477

{

3478

// does not support dynamic configuration

3479

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3480

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

3485

3486

switch (pRegEntry->RegType)

3487

{

3488

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3489

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

3490

if (rv < 0)

3491

goto done;

Jeff Johnson

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

[diff] [blame]

3492

if (value < pRegEntry->VarMin)

3493

{

3494

// out of range

3495

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3496

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3497

goto done;

3498

}

3499

if (value > pRegEntry->VarMax)

3500

{

3501

// out of range

3502

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3503

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3504

goto done;

3505

}

3506

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

3507

break;

3508

3509

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3510

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

3511

if (rv < 0)

3512

goto done;

Jeff Johnson

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

[diff] [blame]

3513

if (value < pRegEntry->VarMin)

3514

{

3515

// out of range

3516

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3517

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3518

goto done;

3519

}

3520

if (value > pRegEntry->VarMax)

3521

{

3522

// out of range

3523

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3524

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3525

goto done;

3526

}

3527

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

3528

break;

3529

3530

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3531

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

3532

if (rv < 0)

3533

goto done;

Jeff Johnson

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

[diff] [blame]

3534

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

3535

{

3536

// out of range

3537

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3538

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

Jeff Johnson

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

[diff] [blame]

3539

goto done;

3540

}

3541

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

3542

{

3543

// out of range

3544

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3545

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

Jeff Johnson

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

[diff] [blame]

3546

goto done;

3547

}

3548

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

3549

break;

3550

3551

case WLAN_PARAM_String:

3552

len_value_str = strlen(value_str);

3553

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

{

// too big

hddLog(LOGE,

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

3558

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3559

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3560

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

3561

goto done;

3562

}

3563

// copy string plus NUL

3564

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

3565

break;

3566

3567

case WLAN_PARAM_MacAddr:

3568

len_value_str = strlen(value_str);

3569

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3574

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3575

__func__, value_str,

Jeff Johnson