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

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

[diff] [blame]

2102

#ifdef WLAN_FEATURE_11AC

2103

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

2104

#endif

2105

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

2106

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

2107

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]

2108

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

Pratik Bhalgat

6bfd142

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

[diff] [blame]

2109

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

Jeff Johnson

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

[diff] [blame]

}

#define CFG_VALUE_MAX_LEN 256

2114

#define CFG_ENTRY_MAX_LEN (32+CFG_VALUE_MAX_LEN)

2115

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

2116

{

2117

unsigned int idx;

2118

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2119

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

2120

v_U32_t value;

2121

char valueStr[CFG_VALUE_MAX_LEN];

2122

char configStr[CFG_ENTRY_MAX_LEN];

2123

char *fmt;

2124

void *pField;

2125

v_MACADDR_t *pMacAddr;

char *pCur = pBuf;

int curlen;

// start with an empty string

2130

*pCur = '\0';

2131

2132

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

2133

{

2134

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

2135

2136

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

2137

( WLAN_PARAM_SignedInteger == pRegEntry->RegType ) ||

2138

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2139

{

2140

value = 0;

2141

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

2142

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

2155

}

2156

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2157

{

2158

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

2159

}

2160

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2161

{

2162

pMacAddr = (v_MACADDR_t *) pField;

2163

snprintf(valueStr, CFG_VALUE_MAX_LEN,

2164

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

2175

}

2176

curlen = snprintf(configStr, CFG_ENTRY_MAX_LEN,

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

pRegEntry->RegName,

valueStr,

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

2181

"*" : "");

2182

2183

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

2184

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

2185

#ifdef RETURN_IN_BUFFER

2186

if (curlen <= buflen)

2187

{

2188

// copy string + '\0'

2189

memcpy(pCur, configStr, curlen+1);

2190

2191

// account for addition;

pCur += curlen;

buflen -= curlen;

}

else

{

// buffer space exhausted, return what we have

2198

return VOS_STATUS_E_RESOURCES;

2199

}

2200

#else

2201

printk(KERN_CRIT "%s", configStr);

2202

#endif // RETURN_IN_BUFFER

}

#ifndef RETURN_IN_BUFFER

2207

// notify application that output is in system log

2208

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

2209

#endif // RETURN_IN_BUFFER

2210

2211

return VOS_STATUS_SUCCESS;

2212

}

2213

2214

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

2215

char *name, char** value)

2216

{

2217

VOS_STATUS status = VOS_STATUS_E_FAILURE;

2218

unsigned long i;

2219

2220

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

2221

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

2222

*value = iniTable[i].value;

2223

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

2224

WLAN_INI_FILE, name, *value);

2225

return VOS_STATUS_SUCCESS;

}

}

return status;

}

static int parseHexDigit(char c)

2233

{

2234

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

2235

return c-'0';

2236

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

2237

return c-'a'+10;

2238

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)

2246

{

2247

VOS_STATUS match_status = VOS_STATUS_E_FAILURE;

2248

VOS_STATUS ret_status = VOS_STATUS_SUCCESS;

2249

unsigned int idx;

2250

void *pField;

2251

char *value_str = NULL;

2252

unsigned long len_value_str;

char *candidate;

v_U32_t value;

v_S31_t svalue;

void *pStructBase = pHddCtx->cfg_ini;

2257

REG_TABLE_ENTRY *pRegEntry = g_registry_table;

2258

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

2259

v_U32_t cbOutString;

2260

int i;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2261

int rv;

Jeff Johnson

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

[diff] [blame]

2262

2263

// sanity test

2264

if (MAX_CFG_INI_ITEMS < cRegTableEntries)

2265

{

2266

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]

2267

__func__, cRegTableEntries);

Jeff Johnson

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

[diff] [blame]

2268

}

2269

2270

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

2271

{

2272

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

2273

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

2274

2275

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

2276

2277

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

2278

{

2279

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

2280

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2281

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2282

ret_status = VOS_STATUS_E_FAILURE;

break;

}

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

2287

( WLAN_PARAM_HexInteger == pRegEntry->RegType ) )

2288

{

2289

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

2290

// If not, use the default value.

2291

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2292

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

2293

if (rv < 0) {

2294

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

2295

__func__, pRegEntry->RegName);

2296

value = pRegEntry->VarDefault;

2297

}

Jeff Johnson

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

[diff] [blame]

2298

}

2299

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2300

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

2301

if (rv < 0) {

2302

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

2303

__func__, pRegEntry->RegName);

2304

value = pRegEntry->VarDefault;

2305

}

Jeff Johnson

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

[diff] [blame]

2306

}

2307

else {

2308

value = pRegEntry->VarDefault;

2309

}

2310

2311

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

2312

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2313

{

2314

if ( value > pRegEntry->VarMax )

2315

{

2316

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2317

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

Jeff Johnson

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

[diff] [blame]

2318

value = pRegEntry->VarMax;

2319

}

2320

2321

if ( value < pRegEntry->VarMin )

2322

{

2323

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2324

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

Jeff Johnson

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

[diff] [blame]

2325

value = pRegEntry->VarMin;

2326

}

2327

}

2328

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

2329

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2330

{

2331

if ( value > pRegEntry->VarMax )

2332

{

2333

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]

2334

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

Jeff Johnson

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

[diff] [blame]

2335

value = pRegEntry->VarDefault;

2336

}

2337

2338

if ( value < pRegEntry->VarMin )

2339

{

2340

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]

2341

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

Jeff Johnson

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

[diff] [blame]

2342

value = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2347

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

2348

}

2349

else if ( WLAN_PARAM_SignedInteger == pRegEntry->RegType )

2350

{

2351

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

2352

// If not, use the default value.

2353

if (VOS_STATUS_SUCCESS == match_status)

2354

{

Madan Mohan Koyyalamudi

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

[diff] [blame]

2355

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

2356

if (rv < 0) {

2357

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

2358

__func__, pRegEntry->RegName);

2359

svalue = (v_S31_t)pRegEntry->VarDefault;

2360

}

Jeff Johnson

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

[diff] [blame]

}

else

{

svalue = (v_S31_t)pRegEntry->VarDefault;

2365

}

2366

2367

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

2368

if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK )

2369

{

2370

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

2371

{

2372

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2373

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

Jeff Johnson

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

[diff] [blame]

2374

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

2375

svalue = (v_S31_t)pRegEntry->VarMax;

2376

}

2377

2378

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

2379

{

2380

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2381

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

Jeff Johnson

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

[diff] [blame]

2382

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

2383

svalue = (v_S31_t)pRegEntry->VarMin;

2384

}

2385

}

2386

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

2387

else if ( pRegEntry->Flags & VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT )

2388

{

2389

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

2390

{

2391

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

2392

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2393

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2394

(int)pRegEntry->VarMax,

2395

(int)pRegEntry->VarDefault );

2396

svalue = (v_S31_t)pRegEntry->VarDefault;

2397

}

2398

2399

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

2400

{

2401

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

2402

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2403

__func__, pRegEntry->RegName, svalue,

Jeff Johnson

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

[diff] [blame]

2404

(int)pRegEntry->VarMin,

2405

(int)pRegEntry->VarDefault);

2406

svalue = pRegEntry->VarDefault;

}

}

// Move the variable into the output field.

2411

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

2412

}

2413

// Handle string parameters

2414

else if ( WLAN_PARAM_String == pRegEntry->RegType )

2415

{

2416

#ifdef WLAN_CFG_DEBUG

2417

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

2418

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

2419

#endif

2420

2421

if ( match_status == VOS_STATUS_SUCCESS)

2422

{

2423

len_value_str = strlen(value_str);

2424

2425

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

2426

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]

2427

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

Jeff Johnson

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

[diff] [blame]

2428

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

2429

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

2430

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

}

else

{

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

2435

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

}

}

else

{

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

2441

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

2442

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

2443

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

2444

}

2445

}

2446

else if ( WLAN_PARAM_MacAddr == pRegEntry->RegType )

2447

{

2448

if(pRegEntry->VarSize != VOS_MAC_ADDR_SIZE) {

2449

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

2450

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

Jeff Johnson

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

[diff] [blame]

2451

continue;

2452

}

2453

candidate = (char*)pRegEntry->VarDefault;

2454

if ( match_status == VOS_STATUS_SUCCESS) {

2455

len_value_str = strlen(value_str);

2456

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

2457

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]

2458

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

Jeff Johnson

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

[diff] [blame]

2459

}

2460

else

2461

candidate = value_str;

2462

}

2463

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

2464

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

2465

{

2466

((char*)pField)[i] =

2467

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

2473

__func__, pRegEntry->RegName);

Jeff Johnson

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

[diff] [blame]

2474

}

2475

2476

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

2477

if( (match_status == VOS_STATUS_SUCCESS) &&

2478

(idx < MAX_CFG_INI_ITEMS) )

2479

{

2480

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

}

}

print_hdd_cfg(pHddCtx);

2485

2486

return( ret_status );

2487

}

2488

2489

eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode( eHddDot11Mode dot11Mode )

{

switch (dot11Mode)

{

case (eHDD_DOT11_MODE_abg):

2494

return eCSR_DOT11_MODE_abg;

2495

case (eHDD_DOT11_MODE_11b):

2496

return eCSR_DOT11_MODE_11b;

2497

case (eHDD_DOT11_MODE_11g):

2498

return eCSR_DOT11_MODE_11g;

2499

default:

2500

case (eHDD_DOT11_MODE_11n):

2501

return eCSR_DOT11_MODE_11n;

2502

case (eHDD_DOT11_MODE_11g_ONLY):

2503

return eCSR_DOT11_MODE_11g_ONLY;

2504

case (eHDD_DOT11_MODE_11n_ONLY):

2505

return eCSR_DOT11_MODE_11n_ONLY;

2506

case (eHDD_DOT11_MODE_11b_ONLY):

2507

return eCSR_DOT11_MODE_11b_ONLY;

Jeff Johnson

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

[diff] [blame]

2508

#ifdef WLAN_FEATURE_11AC

2509

case (eHDD_DOT11_MODE_11ac_ONLY):

2510

return eCSR_DOT11_MODE_11ac_ONLY;

2511

case (eHDD_DOT11_MODE_11ac):

2512

return eCSR_DOT11_MODE_11ac;

2513

#endif

Jeff Johnson

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

[diff] [blame]

2514

case (eHDD_DOT11_MODE_AUTO):

2515

return eCSR_DOT11_MODE_AUTO;

}

}

static void hdd_set_btc_config(hdd_context_t *pHddCtx)

2521

{

2522

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2523

tSmeBtcConfig btcParams;

2524

2525

sme_BtcGetConfig(pHddCtx->hHal, &btcParams);

2526

2527

btcParams.btcExecutionMode = pConfig->btcExecutionMode;

Jeff Johnson

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

[diff] [blame]

2528

btcParams.btcConsBtSlotsToBlockDuringDhcp = pConfig->btcConsBtSlotsToBlockDuringDhcp;

Jeff Johnson

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

[diff] [blame]

2529

btcParams.btcA2DPBtSubIntervalsDuringDhcp = pConfig->btcA2DPBtSubIntervalsDuringDhcp;

2530

Jeff Johnson

32d95a3

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

[diff] [blame]

2531

btcParams.btcStaticLenInqBt = pConfig->btcStaticLenInqBt;

2532

btcParams.btcStaticLenPageBt = pConfig->btcStaticLenPageBt;

2533

btcParams.btcStaticLenConnBt = pConfig->btcStaticLenConnBt;

2534

btcParams.btcStaticLenLeBt = pConfig->btcStaticLenLeBt;

2535

btcParams.btcStaticLenInqWlan = pConfig->btcStaticLenInqWlan;

2536

btcParams.btcStaticLenPageWlan = pConfig->btcStaticLenPageWlan;

2537

btcParams.btcStaticLenConnWlan = pConfig->btcStaticLenConnWlan;

2538

btcParams.btcStaticLenLeWlan = pConfig->btcStaticLenLeWlan;

2539

btcParams.btcDynMaxLenBt = pConfig->btcDynMaxLenBt;

2540

btcParams.btcDynMaxLenWlan = pConfig->btcDynMaxLenWlan;

2541

btcParams.btcMaxScoBlockPerc = pConfig->btcMaxScoBlockPerc;

2542

btcParams.btcDhcpProtOnA2dp = pConfig->btcDhcpProtOnA2dp;

2543

btcParams.btcDhcpProtOnSco = pConfig->btcDhcpProtOnSco;

2544

Jeff Johnson

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

[diff] [blame]

2545

sme_BtcSetConfig(pHddCtx->hHal, &btcParams);

2546

}

2547

2548

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

2549

{

2550

hdd_config_t *pConfig = pHddCtx->cfg_ini;

2551

2552

tPmcBmpsConfigParams bmpsParams;

2553

2554

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

2555

2556

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

2557

{

2558

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

2559

bmpsParams.bmpsPeriod = pConfig->nBmpsMinListenInterval;

2560

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2561

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2562

}

2563

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

2564

{

2565

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

2566

bmpsParams.bmpsPeriod = pConfig->nBmpsMaxListenInterval;

2567

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2568

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2569

}

2570

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

2571

{

2572

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

2573

bmpsParams.bmpsPeriod = pConfig->nBmpsModListenInterval;

2574

bmpsParams.enableBeaconEarlyTermination = pConfig->fEnableBeaconEarlyTermination;

2575

bmpsParams.bcnEarlyTermWakeInterval = pConfig->bcnEarlyTermWakeInterval;

2576

}

2577

2578

if (pConfig->fIsImpsEnabled)

2579

{

2580

sme_EnablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_IDLE_MODE_POWER_SAVE);

2585

}

2586

2587

if (pConfig->fIsBmpsEnabled)

2588

{

2589

sme_EnablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

}

else

{

sme_DisablePowerSave (pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);

2594

}

2595

2596

bmpsParams.trafficMeasurePeriod = pConfig->nAutoBmpsTimerValue;

2597

2598

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

2599

{

2600

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

2601

}

2602

2603

if(pConfig->fIsAutoBmpsTimerEnabled)

2604

{

2605

sme_StartAutoBmpsTimer(pHddCtx->hHal);

}

}

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

2611

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 )

2616

{

2617

return VOS_STATUS_E_INVAL;

}

*len = 0;

#ifdef VERSION_USING_STRPBRK

2622

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

2623

{

2624

int val;

2625

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

2626

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

2627

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

2628

{

2629

intArray[*len] = (tANI_U8) val;

2630

*len += 1;

2631

}

2632

s = strpbrk( s, "," );

if( s )

s++;

}

#else

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

2638

{

2639

unsigned long val;

Madan Mohan Koyyalamudi

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

[diff] [blame]

2640

int rv;

Jeff Johnson

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

[diff] [blame]

2641

Madan Mohan Koyyalamudi

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

[diff] [blame]

2642

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

2643

if (rv < 0)

2644

return VOS_STATUS_E_INVAL;

Jeff Johnson

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

[diff] [blame]

2645

if( val )

2646

{

2647

intArray[*len] = (tANI_U8) val;

*len += 1;

}

if( *s )

s++;

}

#endif

return VOS_STATUS_SUCCESS;

}

#endif

v_BOOL_t hdd_update_config_dat( hdd_context_t *pHddCtx )

2662

{

2663

v_BOOL_t fStatus = TRUE;

2664

2665

hdd_config_t *pConfig = pHddCtx->cfg_ini;

Pratik Bhalgat

6bfd142

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

[diff] [blame]

2666

tSirMacHTCapabilityInfo htCapInfo;

2667

Jeff Johnson

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

[diff] [blame]

2668

2669

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_20MHZ,

2670

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

2671

{

2672

fStatus = FALSE;

2673

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

2674

}

2675

2676

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

2677

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2678

{

2679

fStatus = FALSE;

2680

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

2681

}

2682

2683

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

2684

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2685

{

2686

fStatus = FALSE;

2687

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

2688

}

2689

2690

if ( 0 != pConfig->Cfg1Id )

2691

{

2692

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

2693

eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2694

{

2695

fStatus = FALSE;

2696

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

}

}

if ( 0 != pConfig->Cfg2Id )

2702

{

2703

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

2704

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2705

{

2706

fStatus = FALSE;

2707

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

}

}

if ( 0 != pConfig->Cfg3Id )

2712

{

2713

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

2714

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2715

{

2716

fStatus = FALSE;

2717

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

}

}

if ( 0 != pConfig->Cfg4Id )

2722

{

2723

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

2724

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2725

{

2726

fStatus = FALSE;

2727

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

}

}

if ( 0 != pConfig->Cfg5Id )

2732

{

2733

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

2734

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2735

{

2736

fStatus = FALSE;

2737

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

}

}

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

2742

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2743

{

2744

fStatus = FALSE;

2745

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

2746

}

2747

2748

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

2749

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2750

{

2751

fStatus = FALSE;

2752

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

2753

}

2754

2755

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_MAX_RX_AMPDU_FACTOR,

2756

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

2757

{

2758

fStatus = FALSE;

2759

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

2760

}

2761

2762

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

2763

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2764

{

2765

fStatus = FALSE;

2766

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

2767

}

2768

2769

if (pConfig->fIsAutoIbssBssid)

2770

{

2771

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

2772

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

2773

{

2774

fStatus = FALSE;

2775

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

}

}

else

{

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

2781

{

2782

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,

2783

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

2784

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

2785

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

2786

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

2787

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

2788

{

2789

fStatus = FALSE;

2790

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,

2801

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2802

{

2803

fStatus = FALSE;

2804

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

2805

}

2806

2807

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

2808

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2809

{

2810

fStatus = FALSE;

2811

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

2812

}

2813

2814

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

2815

{

2816

fStatus = FALSE;

2817

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

2818

}

2819

2820

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

2821

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2822

{

2823

fStatus = FALSE;

2824

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

2825

}

2826

2827

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

2828

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2829

{

2830

fStatus = FALSE;

2831

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

2832

}

2833

Jeff Johnson

04dd8a8

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

[diff] [blame]

2834

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

2835

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

2836

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2837

{

2838

fStatus = FALSE;

2839

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,

2844

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2845

{

2846

fStatus = FALSE;

2847

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

2848

}

2849

2850

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

2851

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2852

{

2853

fStatus = FALSE;

2854

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

2855

}

2856

2857

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

2858

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2859

{

2860

fStatus = FALSE;

2861

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

2862

}

2863

2864

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

2865

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2866

{

2867

fStatus = FALSE;

2868

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

2869

}

2870

2871

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

2872

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2873

{

2874

fStatus = FALSE;

2875

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

2876

}

2877

2878

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

2879

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2880

{

2881

fStatus = FALSE;

2882

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

2883

}

2884

2885

#ifdef WLAN_SOFTAP_FEATURE

2886

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

2887

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2888

{

2889

fStatus = FALSE;

2890

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

2891

}

2892

2893

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

2894

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2895

{

2896

fStatus = FALSE;

2897

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

2898

}

2899

Jeff Johnson

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

[diff] [blame]

2900

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

2901

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2902

{

2903

fStatus = FALSE;

2904

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

2905

}

2906

2907

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

2908

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2909

{

2910

fStatus = FALSE;

2911

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

}

#endif

#if defined WLAN_FEATURE_VOWIFI

2916

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

2917

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2918

{

2919

fStatus = FALSE;

2920

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

2921

}

2922

2923

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

2924

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2925

{

2926

fStatus = FALSE;

2927

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

2928

}

2929

2930

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

2931

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2932

{

2933

fStatus = FALSE;

2934

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

2935

}

2936

2937

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

2938

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2939

#endif

2940

2941

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

2942

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2943

{

2944

fStatus = FALSE;

2945

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

2946

}

2947

2948

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

2949

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2950

{

2951

fStatus = FALSE;

2952

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

2953

}

2954

2955

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

2956

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2957

{

2958

fStatus = FALSE;

2959

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

2960

}

2961

2962

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

2963

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2964

{

2965

fStatus = FALSE;

2966

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

2967

}

2968

2969

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

2970

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2971

{

2972

fStatus = FALSE;

2973

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

2974

}

2975

2976

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

2977

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2978

{

2979

fStatus = FALSE;

2980

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

2981

}

2982

2983

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

2984

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2985

{

2986

fStatus = FALSE;

2987

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

2988

}

2989

2990

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

2991

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2992

{

2993

fStatus = FALSE;

2994

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

2995

}

2996

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

2997

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

2998

{

2999

fStatus = FALSE;

3000

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

3001

}

3002

3003

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

3004

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3005

{

3006

fStatus = FALSE;

3007

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

3008

}

3009

3010

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

3011

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3012

{

3013

fStatus = FALSE;

3014

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

3015

}

3016

#ifdef FEATURE_WLAN_INTEGRATED_SOC

3017

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

3018

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3019

{

3020

fStatus = FALSE;

3021

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

3022

}

3023

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

3024

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3025

{

3026

fStatus = FALSE;

3027

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

3028

}

3029

3030

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

3031

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3032

{

3033

fStatus = FALSE;

3034

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

3035

}

3036

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

3037

NULL, eANI_BOOLEAN_FALSE) == eHAL_STATUS_FAILURE)

3038

{

3039

fStatus = FALSE;

3040

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,

3045

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3046

{

3047

fStatus = FALSE;

3048

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

3049

}

3050

3051

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_ENABLE_CLOSE_LOOP,

3052

pConfig->enableCloseLoop, NULL, eANI_BOOLEAN_FALSE)

3053

==eHAL_STATUS_FAILURE)

3054

{

3055

fStatus = FALSE;

3056

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

3057

}

3058

3059

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_TX_PWR_CTRL_ENABLE,

3060

pConfig->enableAutomaticTxPowerControl, NULL, eANI_BOOLEAN_FALSE)

3061

==eHAL_STATUS_FAILURE)

3062

{

3063

fStatus = FALSE;

3064

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

3065

}

3066

3067

if (ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_SHORT_GI_40MHZ,

3068

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

3069

{

3070

fStatus = FALSE;

3071

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

3072

}

3073

Jeff Johnson

d13512a

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

[diff] [blame]

3074

3075

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

3076

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3077

{

3078

fStatus = FALSE;

3079

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

3080

}

3081

Jeff Johnson

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

[diff] [blame]

3082

#ifdef WLAN_FEATURE_11AC

3083

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

3084

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

3085

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

3086

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

3087

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac_ONLY) ||

3088

(pConfig->dot11Mode == eHDD_DOT11_MODE_11ac) )

{

{

tANI_U32 temp = 0;

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

3094

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

3095

3096

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_BASIC_MCS_SET,

3097

temp, NULL, eANI_BOOLEAN_FALSE)

3098

==eHAL_STATUS_FAILURE)

3099

{

3100

fStatus = FALSE;

3101

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

3102

}

3103

3104

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

3105

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

3106

3107

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RX_MCS_MAP,

3108

temp, NULL, eANI_BOOLEAN_FALSE)

3109

==eHAL_STATUS_FAILURE)

3110

{

3111

fStatus = FALSE;

3112

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

3113

}

3114

3115

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

3116

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

3117

3118

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_TX_MCS_MAP,

3119

temp, NULL, eANI_BOOLEAN_FALSE)

3120

==eHAL_STATUS_FAILURE)

3121

{

3122

fStatus = FALSE;

3123

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]

3129

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

3130

NULL, eANI_BOOLEAN_FALSE)==eHAL_STATUS_FAILURE)

3131

{

3132

fStatus = FALSE;

3133

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

3134

}

3135

Pratik Bhalgat

6bfd142

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

[diff] [blame]

3136

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_RX_STBC,

3137

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3138

==eHAL_STATUS_FAILURE)

3139

{

3140

fStatus = FALSE;

3141

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

3142

}

3143

3144

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

3145

htCapInfo.rxSTBC = pConfig->enableRxSTBC;

3146

3147

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_HT_CAP_INFO,

3148

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

3149

==eHAL_STATUS_FAILURE)

3150

{

3151

fStatus = FALSE;

3152

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

3153

}

3154

3155

if(ccmCfgSetInt(pHddCtx->hHal, WNI_CFG_VHT_RXSTBC,

3156

pConfig->enableRxSTBC, NULL, eANI_BOOLEAN_FALSE)

3157

==eHAL_STATUS_FAILURE)

3158

{

3159

fStatus = FALSE;

3160

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

3161

}

3162

Jeff Johnson

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

[diff] [blame]

return fStatus;

}

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

3168

3169

\brief hdd_init_set_sme_config() -

3170

3171

This function initializes the sme configuration parameters

3172

3173

\param - pHddCtx - Pointer to the HDD Adapter.

3174

3175

\return - 0 for success, non zero for failure

3176

3177

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

3178

3179

VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )

3180

{

3181

VOS_STATUS status = VOS_STATUS_SUCCESS;

3182

eHalStatus halStatus;

3183

tSmeConfigParams smeConfig;

3184

3185

hdd_config_t *pConfig = pHddCtx->cfg_ini;

3186

3187

vos_mem_zero( &smeConfig, sizeof( smeConfig ) );

3188

3189

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,

3190

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

3191

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

3192

3193

// Config params obtained from the registry

Madan Mohan Koyyalamudi

c3a240c

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

[diff] [blame]

3194

if (is_crda_regulatory_entry_valid() == VOS_TRUE)

3195

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

Jeff Johnson

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

[diff] [blame]

3196

smeConfig.csrConfig.RTSThreshold = pConfig->RTSThreshold;

3197

smeConfig.csrConfig.FragmentationThreshold = pConfig->FragmentationThreshold;

3198

smeConfig.csrConfig.shortSlotTime = pConfig->ShortSlotTimeEnabled;

3199

smeConfig.csrConfig.Is11dSupportEnabled = pConfig->Is11dSupportEnabled;

3200

smeConfig.csrConfig.HeartbeatThresh24 = pConfig->HeartbeatThresh24;

3201

3202

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

3203

3204

smeConfig.csrConfig.channelBondingMode24GHz = pConfig->nChannelBondingMode24GHz;

3205

smeConfig.csrConfig.channelBondingMode5GHz = pConfig->nChannelBondingMode5GHz;

3206

smeConfig.csrConfig.TxRate = pConfig->TxRate;

3207

smeConfig.csrConfig.nScanResultAgeCount = pConfig->ScanResultAgeCount;

3208

smeConfig.csrConfig.scanAgeTimeNCNPS = pConfig->nScanAgeTimeNCNPS;

3209

smeConfig.csrConfig.scanAgeTimeNCPS = pConfig->nScanAgeTimeNCPS;

3210

smeConfig.csrConfig.scanAgeTimeCNPS = pConfig->nScanAgeTimeCNPS;

3211

smeConfig.csrConfig.scanAgeTimeCPS = pConfig->nScanAgeTimeCPS;

3212

smeConfig.csrConfig.AdHocChannel24 = pConfig->OperatingChannel;

3213

smeConfig.csrConfig.fEnforce11dChannels = pConfig->fEnforce11dChannels;

3214

smeConfig.csrConfig.fSupplicantCountryCodeHasPriority = pConfig->fSupplicantCountryCodeHasPriority;

3215

smeConfig.csrConfig.fEnforceCountryCodeMatch = pConfig->fEnforceCountryCodeMatch;

3216

smeConfig.csrConfig.fEnforceDefaultDomain = pConfig->fEnforceDefaultDomain;

3217

smeConfig.csrConfig.bCatRssiOffset = pConfig->nRssiCatGap;

3218

smeConfig.csrConfig.vccRssiThreshold = pConfig->nVccRssiTrigger;

3219

smeConfig.csrConfig.vccUlMacLossThreshold = pConfig->nVccUlMacLossThreshold;

3220

smeConfig.csrConfig.nRoamingTime = pConfig->nRoamingTime;

3221

smeConfig.csrConfig.IsIdleScanEnabled = pConfig->nEnableIdleScan;

3222

smeConfig.csrConfig.nActiveMaxChnTime = pConfig->nActiveMaxChnTime;

3223

smeConfig.csrConfig.nActiveMinChnTime = pConfig->nActiveMinChnTime;

3224

smeConfig.csrConfig.nPassiveMaxChnTime = pConfig->nPassiveMaxChnTime;

3225

smeConfig.csrConfig.nPassiveMinChnTime = pConfig->nPassiveMinChnTime;

Madan Mohan Koyyalamudi

4ff9cd6

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

[diff] [blame]

3226

#ifdef WLAN_AP_STA_CONCURRENCY

3227

smeConfig.csrConfig.nActiveMaxChnTimeConc = pConfig->nActiveMaxChnTimeConc;

3228

smeConfig.csrConfig.nActiveMinChnTimeConc = pConfig->nActiveMinChnTimeConc;

3229

smeConfig.csrConfig.nPassiveMaxChnTimeConc = pConfig->nPassiveMaxChnTimeConc;

3230

smeConfig.csrConfig.nPassiveMinChnTimeConc = pConfig->nPassiveMinChnTimeConc;

3231

smeConfig.csrConfig.nRestTimeConc = pConfig->nRestTimeConc;

3232

#endif

Jeff Johnson

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

[diff] [blame]

3233

smeConfig.csrConfig.Is11eSupportEnabled = pConfig->b80211eIsEnabled;

3234

smeConfig.csrConfig.WMMSupportMode = pConfig->WmmMode;

3235

3236

#if defined WLAN_FEATURE_VOWIFI

3237

smeConfig.rrmConfig.rrmEnabled = pConfig->fRrmEnable;

3238

smeConfig.rrmConfig.maxRandnInterval = pConfig->nRrmRandnIntvl;

3239

#endif

3240

//Remaining config params not obtained from registry

3241

// On RF EVB beacon using channel 1.

Jeff Johnson

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

[diff] [blame]

3242

#ifdef WLAN_FEATURE_11AC

3243

smeConfig.csrConfig.nVhtChannelWidth = pConfig->vhtChannelWidth;

3244

#endif

Jeff Johnson

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

[diff] [blame]

3245

smeConfig.csrConfig.AdHocChannel5G = 44;

3246

smeConfig.csrConfig.ProprietaryRatesEnabled = 0;

3247

smeConfig.csrConfig.HeartbeatThresh50 = 40;

Jeff Johnson

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

[diff] [blame]

3248

smeConfig.csrConfig.Is11hSupportEnabled = 1;

Jeff Johnson

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

[diff] [blame]

3249

smeConfig.csrConfig.bandCapability = pConfig->nBandCapability;

3250

smeConfig.csrConfig.cbChoice = 0;

3251

smeConfig.csrConfig.bgScanInterval = 0;

3252

smeConfig.csrConfig.eBand = pConfig->nBandCapability;

3253

smeConfig.csrConfig.nTxPowerCap = pConfig->nTxPowerCap;

3254

smeConfig.csrConfig.fEnableBypass11d = pConfig->enableBypass11d;

3255

smeConfig.csrConfig.fEnableDFSChnlScan = pConfig->enableDFSChnlScan;

Madan Mohan Koyyalamudi

3f65e31

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

[diff] [blame]

3256

smeConfig.csrConfig.fIgnore_chan165 = pConfig->ignore_chan165;

Madan Mohan Koyyalamudi

d502607

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

[diff] [blame]

3257

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

3258

smeConfig.csrConfig.nRoamPrefer5GHz = pConfig->nRoamPrefer5GHz;

3259

#endif

Jeff Johnson

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

[diff] [blame]

3260

smeConfig.csrConfig.fFirstScanOnly2GChnl = pConfig->enableFirstScan2GOnly;

3261

Jeff Johnson

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

[diff] [blame]

3262

//FIXME 11d config is hardcoded

3263

#ifdef WLAN_SOFTAP_FEATURE

3264

if ( VOS_STA_SAP_MODE != hdd_get_conparam()){

3265

#endif

3266

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

3267

3268

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

3269

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

3270

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

3271

3272

#ifdef WLAN_SOFTAP_FEATURE

}

else{

VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

3277

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

3278

3279

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

3280

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

3281

sme_set11dinfo(pHddCtx->hHal, &smeConfig);

3282

}

3283

#endif

3284

hdd_set_power_save_config(pHddCtx, &smeConfig);

3285

hdd_set_btc_config(pHddCtx);

3286

3287

#ifdef WLAN_FEATURE_VOWIFI_11R

3288

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

3289

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3290

#ifdef FEATURE_WLAN_LFR

3291

smeConfig.csrConfig.isFastRoamIniFeatureEnabled = pConfig->isFastRoamIniFeatureEnabled;

3292

#endif

Jeff Johnson

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

[diff] [blame]

3293

#ifdef FEATURE_WLAN_CCX

3294

smeConfig.csrConfig.isCcxIniFeatureEnabled = pConfig->isCcxIniFeatureEnabled;

3295

#endif

Jeff Johnson

04dd8a8

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

[diff] [blame]

3296

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

3297

smeConfig.csrConfig.isFastTransitionEnabled = pConfig->isFastTransitionEnabled;

Jeff Johnson

43971f5

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

[diff] [blame]

3298

smeConfig.csrConfig.RoamRssiDiff = pConfig->RoamRssiDiff;

Madan Mohan Koyyalamudi

62b55b0

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

[diff] [blame]

3299

smeConfig.csrConfig.nImmediateRoamRssiDiff = pConfig->nImmediateRoamRssiDiff;

Jeff Johnson

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

[diff] [blame]

3300

#endif

3301

3302

#ifdef WLAN_FEATURE_NEIGHBOR_ROAMING

3303

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

3304

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

3305

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

3306

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

3307

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

3308

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

3309

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

3310

hdd_string_to_u8_array( pConfig->neighborScanChanList,

3311

smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.channelList,

3312

&smeConfig.csrConfig.neighborRoamConfig.neighborScanChanList.numChannels,

3313

WNI_CFG_VALID_CHANNEL_LIST_LEN );

3314

#endif

3315

3316

smeConfig.csrConfig.addTSWhenACMIsOff = pConfig->AddTSWhenACMIsOff;

3317

smeConfig.csrConfig.fValidateList = pConfig->fValidateScanList;

3318

3319

//Enable/Disable MCC

3320

smeConfig.csrConfig.fEnableMCCMode = pConfig->enableMCC;

Mohit Khanna

7ed53f0

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

[diff] [blame]

3321

smeConfig.csrConfig.fAllowMCCGODiffBI = pConfig->allowMCCGODiffBI;

Jeff Johnson

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

[diff] [blame]

3322

3323

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

3324

if ( !HAL_STATUS_SUCCESS( halStatus ) )

3325

{

3326

status = VOS_STATUS_E_FAILURE;

}

return status;

}

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

3335

3336

\brief hdd_execute_config_command() -

3337

3338

This function executes an arbitrary configuration set command

3339

3340

\param - pHddCtx - Pointer to the HDD Adapter.

3341

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

3342

3343

3344

\return - 0 for success, non zero for failure

3345

3346

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

3347

3348

VOS_STATUS hdd_execute_config_command(hdd_context_t *pHddCtx, char *command)

3349

{

3350

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

3351

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;

3360

unsigned int idx;

3361

unsigned int i;

3362

VOS_STATUS vstatus;

Madan Mohan Koyyalamudi

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

[diff] [blame]

3363

int rv;

Jeff Johnson

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

[diff] [blame]

3364

3365

// assume failure until proven otherwise

3366

vstatus = VOS_STATUS_E_FAILURE;

3367

3368

// clone the command so that we can manipulate it

3369

clone = kstrdup(command, GFP_ATOMIC);

3370

if (NULL == clone)

3371

{

3372

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3373

__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

3378

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

3379

pCmd = clone;

3380

3381

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

3387

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// parse the <name> = <value>

3392

name = pCmd;

3393

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]

3401

__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

3411

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3412

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

value_str = i_trim(pCmd);

3417

if ('\0' == *value_str)

3418

{

3419

// did not find a value

3420

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3421

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

// lookup the configuration item

3426

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

3427

{

3428

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

{

// found a match

break;

}

}

if (tableSize == idx)

3435

{

3436

// did not match the name

3437

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3438

__func__, command);

Jeff Johnson

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

[diff] [blame]

goto done;

}

pRegEntry = &g_registry_table[idx];

3443

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

3444

{

3445

// does not support dynamic configuration

3446

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3447

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

3452

3453

switch (pRegEntry->RegType)

3454

{

3455

case WLAN_PARAM_Integer:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3456

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

3457

if (rv < 0)

3458

goto done;

Jeff Johnson

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

[diff] [blame]

3459

if (value < pRegEntry->VarMin)

3460

{

3461

// out of range

3462

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3463

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3464

goto done;

3465

}

3466

if (value > pRegEntry->VarMax)

3467

{

3468

// out of range

3469

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3470

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3471

goto done;

3472

}

3473

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

3474

break;

3475

3476

case WLAN_PARAM_HexInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3477

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

3478

if (rv < 0)

3479

goto done;

Jeff Johnson

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

[diff] [blame]

3480

if (value < pRegEntry->VarMin)

3481

{

3482

// out of range

3483

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3484

__func__, value, pRegEntry->VarMin);

Jeff Johnson

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

[diff] [blame]

3485

goto done;

3486

}

3487

if (value > pRegEntry->VarMax)

3488

{

3489

// out of range

3490

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3491

__func__, value, pRegEntry->VarMax);

Jeff Johnson

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

[diff] [blame]

3492

goto done;

3493

}

3494

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

3495

break;

3496

3497

case WLAN_PARAM_SignedInteger:

Madan Mohan Koyyalamudi

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

[diff] [blame]

3498

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

3499

if (rv < 0)

3500

goto done;

Jeff Johnson

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

[diff] [blame]

3501

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

3502

{

3503

// out of range

3504

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3505

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

Jeff Johnson

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

[diff] [blame]

3506

goto done;

3507

}

3508

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

3509

{

3510

// out of range

3511

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

Madan Mohan Koyyalamudi

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

[diff] [blame]

3512

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

Jeff Johnson

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

[diff] [blame]

3513

goto done;

3514

}

3515

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

3516

break;

3517

3518

case WLAN_PARAM_String:

3519

len_value_str = strlen(value_str);

3520

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

{

// too big

hddLog(LOGE,

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

3525

"%u exceeds maximum length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3526

__func__, value_str,

Jeff Johnson

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

[diff] [blame]

3527

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

3528

goto done;

3529

}

3530

// copy string plus NUL

3531

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

3532

break;

3533

3534

case WLAN_PARAM_MacAddr:

3535

len_value_str = strlen(value_str);

3536

if (len_value_str != (VOS_MAC_ADDR_SIZE * 2))

{

// out of range

hddLog(LOGE,

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

3541

"%u is not expected length %u",

Madan Mohan Koyyalamudi

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

[diff] [blame]

3542

__func__, value_str,

Jeff Johnson