/*******************************************************************************
**
** Function: nfc_hal_post_reset_init
**
** Description: Called by the NFC HAL after controller has been reset.
** Begin to download firmware patch files.
**
** Returns: none
**
*******************************************************************************/
void nfc_hal_post_reset_init (UINT32 brcm_hw_id, UINT8 nvm_type)
{
ALOGD("%s: brcm_hw_id=0x%lx, nvm_type=%d", __FUNCTION__, brcm_hw_id, nvm_type);
tHAL_NFC_STATUS stat = HAL_NFC_STATUS_FAILED;
UINT8 max_credits = 1, allow_no_nvm=0;
p_nfc_hal_cfg->nfc_hal_prm_nvm_required = TRUE; //don't download firmware if controller cannot detect EERPOM
if (nvm_type == NCI_SPD_NVM_TYPE_NONE)
{
GetNumValue(NAME_ALLOW_NO_NVM, &allow_no_nvm, sizeof(allow_no_nvm));
if (allow_no_nvm == 0)
{
ALOGD("%s: No NVM detected, FAIL the init stage to force a retry", __FUNCTION__);
USERIAL_PowerupDevice (0);
stat = HAL_NfcReInit ();
return;
}
p_nfc_hal_cfg->nfc_hal_prm_nvm_required = FALSE; //allow download firmware if controller cannot detect EERPOM
}
/* Start downloading the patch files */
StartPatchDownload(brcm_hw_id);
if (GetNumValue(MAX_RF_DATA_CREDITS, &max_credits, sizeof(max_credits)) && (max_credits > 0))
{
ALOGD("%s : max_credits=%d", __FUNCTION__, max_credits);
HAL_NfcSetMaxRfDataCredits(max_credits);
}
}
/*******************************************************************************
**
** Function: configureCrystalFrequency
**
** Description: Configure controller's crystal frequency by reading values from
** .conf file. If .conf file does not define any value, then use
** default values defined in struct nfc_post_reset_cb.
**
** Returns: none
**
*******************************************************************************/
void configureCrystalFrequency ()
{
unsigned long num = 0;
UINT32 hwId = 0;
UINT16 xtalFreq = 0;
UINT8 xtalIndex = 0;
int actualLen = 0;
if (GetNumValue (NAME_XTAL_HARDWARE_ID, &num, sizeof(num)))
hwId = num;
if (GetNumValue (NAME_XTAL_FREQUENCY, &num, sizeof(num)))
xtalFreq = (UINT16) num;
if (GetNumValue (NAME_XTAL_FREQ_INDEX, &num, sizeof(num)))
xtalIndex = (UINT8) num;
actualLen = GetStrValue (NAME_XTAL_PARAMS_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen && (xtalIndex == NFC_HAL_XTAL_INDEX_SPECIAL)) //whether to use custom crystal frequency
{
sXtalCustomParam.append (sConfig, actualLen);
p_nfc_hal_dm_xtal_params_cfg = const_cast<UINT8*> (sXtalCustomParam.getInternalBuffer ());
}
if ((hwId == 0) && (xtalFreq == 0) && (xtalIndex == 0))
return;
ALOGD ("%s: hwId=0x%lX; freq=%u; index=%u", __FUNCTION__, hwId, xtalFreq, xtalIndex);
nfc_post_reset_cb.dev_init_config.xtal_cfg[0].brcm_hw_id = (hwId & BRCM_NFC_GEN_MASK);
nfc_post_reset_cb.dev_init_config.xtal_cfg[0].xtal_freq = xtalFreq;
nfc_post_reset_cb.dev_init_config.xtal_cfg[0].xtal_index = xtalIndex;
nfc_post_reset_cb.dev_init_config.num_xtal_cfg = 1;
}
/*=== ValidateNum (PUBLIC) only range validation !=================================================
Insures that the integer passed in is valid. First and
second argument are required.
The first and second argument indicate the required range for int
Returns: TRUE when int is valid; FALSE when int is not valid
==========================================================================*/
BOOL
CArborEdit::ValidateNum ( int min_val, int max_val )
{
if( EditStyleIs(EDIT_NUMERIC) )
{ // ok!
CString ControlText, sMaxInt;
GetWindowText(ControlText);
// if empty valid by default...
sMaxInt.Format("%d", INT_MAX);
if(strlen(ControlText) >= strlen(sMaxInt))
{
if(strcmp(ControlText, sMaxInt) > 0) // string comparison for int overflow
{
return FALSE;
}
}
// if the function has been called without params, set the values to the range values
// if they were set....
if( m_bIntRangeSet && min_val == 0 && max_val == 0.0 )
{
min_val = m_iMinValue;
max_val = m_iMaxValue;
}
if( min_val >= INT_MIN && max_val <= INT_MAX && // validate range user specified
min_val <= GetNumValue() && max_val >= GetNumValue() )
return TRUE;
else
return FALSE;
}
else
// you don't have permision to use ValidateInt function to validate Letter string
return FALSE;
}
/*******************************************************************************
**
** Function: NfcAdaptation::Initialize()
**
** Description: class initializer
**
** Returns: none
**
*******************************************************************************/
void NfcAdaptation::Initialize ()
{
const char* func = "NfcAdaptation::Initialize";
ALOGD("%s: enter", func);
ALOGE("%s: ver=%s nfa=%s", func, nfca_version_string, nfa_version_string);
unsigned long num;
if ( !GetStrValue ( NAME_NFA_STORAGE, bcm_nfc_location, sizeof ( bcm_nfc_location ) ) )
{
memset (bcm_nfc_location, 0, sizeof(bcm_nfc_location));
strncpy (bcm_nfc_location, "/data/nfc", 9);
}
if ( GetNumValue ( NAME_PROTOCOL_TRACE_LEVEL, &num, sizeof ( num ) ) )
ScrProtocolTraceFlag = num;
if ( GetStrValue ( NAME_NFA_DM_CFG, (char*)nfa_dm_cfg, sizeof ( nfa_dm_cfg ) ) )
p_nfa_dm_cfg = ( tNFA_DM_CFG * ) &nfa_dm_cfg[0];
if ( GetNumValue ( NAME_NFA_MAX_EE_SUPPORTED, &num, sizeof ( num ) ) )
{
nfa_ee_max_ee_cfg = num;
ALOGD("%s: Overriding NFA_EE_MAX_EE_SUPPORTED to use %d", func, nfa_ee_max_ee_cfg);
}
initializeGlobalAppLogLevel ();
verify_stack_non_volatile_store ();
if ( GetNumValue ( NAME_PRESERVE_STORAGE, (char*)&num, sizeof ( num ) ) &&
(num == 1) )
ALOGD ("%s: preserve stack NV store", __FUNCTION__);
else
{
delete_stack_non_volatile_store (FALSE);
}
GKI_init ();
GKI_enable ();
GKI_create_task ((TASKPTR)NFCA_TASK, BTU_TASK, (INT8*)"NFCA_TASK", 0, 0, (pthread_cond_t*)NULL, NULL);
{
AutoThreadMutex guard(mCondVar);
GKI_create_task ((TASKPTR)Thread, MMI_TASK, (INT8*)"NFCA_THREAD", 0, 0, (pthread_cond_t*)NULL, NULL);
mCondVar.wait();
}
mHalDeviceContext = NULL;
mHalCallback = NULL;
memset (&mHalEntryFuncs, 0, sizeof(mHalEntryFuncs));
InitializeHalDeviceContext ();
ALOGD ("%s: exit", func);
}
// Conversion from CArborEdit to int.
CArborEdit::operator int()
{
if( EditStyleIs(EDIT_NUMERIC) )
return(GetNumValue());
else // you don't have permition to use this function
return 0;
}
/*******************************************************************************
**
** Function: initialize
**
** Description: Initialize member variables.
**
** Returns: None
**
*******************************************************************************/
void PowerSwitch::initialize (PowerLevel level)
{
static const char fn [] = "PowerSwitch::initialize";
unsigned long num = 0;
mMutex.lock ();
ALOGD ("%s: level=%s (%u)", fn, powerLevelToString(level), level);
if (GetNumValue (NAME_SCREEN_OFF_POWER_STATE, &num, sizeof(num)))
mDesiredScreenOffPowerState = (int) num;
ALOGD ("%s: desired screen-off state=%d", fn, mDesiredScreenOffPowerState);
switch (level)
{
case FULL_POWER:
mCurrDeviceMgtPowerState = NFA_DM_PWR_MODE_FULL;
mCurrLevel = level;
break;
case UNKNOWN_LEVEL:
mCurrDeviceMgtPowerState = NFA_DM_PWR_STATE_UNKNOWN;
mCurrLevel = level;
break;
default:
ALOGE ("%s: not handled", fn);
break;
}
mMutex.unlock ();
}
/*******************************************************************************
**
** Function: InitializeGlobalAppLogLevel
**
** Description: Initialize and get global logging level from
** Android property nfc.app_log_level.
**
** Returns: Global log level:
** BT_TRACE_LEVEL_NONE 0 * No trace messages to be generated
** BT_TRACE_LEVEL_ERROR 1 * Error condition trace messages
** BT_TRACE_LEVEL_WARNING 2 * Warning condition trace messages
** BT_TRACE_LEVEL_API 3 * API traces
** BT_TRACE_LEVEL_EVENT 4 * Debug messages for events
** BT_TRACE_LEVEL_DEBUG 5 * Debug messages (general)
**
*******************************************************************************/
unsigned char InitializeGlobalAppLogLevel ()
{
unsigned long num = 0;
char valueStr [PROPERTY_VALUE_MAX] = {0};
num = 1;
if (GetNumValue (NAME_APPL_TRACE_LEVEL, &num, sizeof(num)))
appl_trace_level = (unsigned char) num;
int len = property_get ("nfc.app_log_level", valueStr, "");
if (len > 0)
{
//let Android property override default value
sscanf (valueStr, "%lu", &num);
appl_trace_level = (unsigned char) num;
}
//0xFF is a special value used by the stack to query the current
//trace level; it does not change any trace level
if (appl_trace_level == 0xFF)
appl_trace_level = BT_TRACE_LEVEL_DEBUG;
ALOGD ("%s: level=%u", __FUNCTION__, appl_trace_level);
if (appl_trace_level < BT_TRACE_LEVEL_DEBUG)
{
//display protocol traces in raw format
ProtoDispAdapterUseRawOutput (TRUE);
}
return appl_trace_level;
}
bool RoutingManager::initialize ()
{
unsigned long tech = 0;
UINT8 mActualNumEe = 0;
tNFA_EE_INFO mEeInfo [mActualNumEe];
if ((GetNumValue(NAME_NXP_FWD_FUNCTIONALITY_ENABLE, &tech, sizeof(tech))))
{
mFwdFuntnEnable = tech;
NXPLOG_API_E ("%s:NXP_FWD_FUNCTIONALITY_ENABLE=%d;", __FUNCTION__, mFwdFuntnEnable);
}
tNFA_STATUS nfaStat;
{
SyncEventGuard guard (mEeRegisterEvent);
NXPLOG_API_D ("%s: try ee register", "RoutingManager::initialize()");
nfaStat = NFA_EeRegister (nfaEeCallback);
if (nfaStat != NFA_STATUS_OK)
{
NXPLOG_API_E ("%s: fail ee register; error=0x%X",
"RoutingManager::initialize()", nfaStat);
return false;
}
mEeRegisterEvent.wait ();
}
if(mHostListnEnable)
{
// Tell the host-routing to only listen on Nfc-A/Nfc-B
nfaStat = NFA_CeRegisterAidOnDH (NULL, 0, stackCallback);
if (nfaStat != NFA_STATUS_OK)
{
NXPLOG_API_E ("Failed to register wildcard AID for DH");
}
// Tell the host-routing to only listen on Nfc-A/Nfc-B
nfaStat = NFA_CeSetIsoDepListenTech(NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B);
if (nfaStat != NFA_STATUS_OK)
{
NXPLOG_API_E ("Failed to configure CE IsoDep technologies");
}
}
memset(mRxDataBuffer, 0, MAX_CE_RX_BUFFER_SIZE);
if ((nfaStat = NFA_AllEeGetInfo (&mActualNumEe, mEeInfo)) != NFA_STATUS_OK)
{
NXPLOG_API_E ("%s: fail get info; error=0x%X",
"RoutingManager::initialize()", nfaStat);
mActualNumEe = 0;
}
return true;
}
RoutingManager::RoutingManager ()
{
static const char fn [] = "RoutingManager::RoutingManager()";
unsigned long num = 0;
// Get the active SE
if (GetNumValue("ACTIVE_SE", &num, sizeof(num)))
mActiveSe = num;
else
mActiveSe = 0x00;
// Get the "default" route
if (GetNumValue("DEFAULT_ISODEP_ROUTE", &num, sizeof(num)))
mDefaultEe = num;
else
mDefaultEe = 0x00;
ALOGD("%s: default route is 0x%02X", fn, mDefaultEe);
// Get the default "off-host" route. This is hard-coded at the Java layer
// but we can override it here to avoid forcing Java changes.
if (GetNumValue("DEFAULT_OFFHOST_ROUTE", &num, sizeof(num)))
mOffHostEe = num;
else
mOffHostEe = 0xf4;
if (GetNumValue("AID_MATCHING_MODE", &num, sizeof(num)))
mAidMatchingMode = num;
else
mAidMatchingMode = AID_MATCHING_EXACT_ONLY;
ALOGD("%s: mOffHostEe=0x%02X", fn, mOffHostEe);
memset (&mEeInfo, 0, sizeof(mEeInfo));
mReceivedEeInfo = false;
mSeTechMask = 0x00;
}
/*******************************************************************************
**
** Function getNfaValues
**
** Description Get configuration values needed by NFA layer
**
** Returns: None
**
*******************************************************************************/
static void getNfaValues (UINT32 chipid)
{
unsigned long num = 0;
int actualLen = 0;
sStartupConfig.initialize ();
sLptdConfig.initialize ();
sPreDiscoveryConfig.initialize();
actualLen = GetStrValue (NAME_NFA_DM_START_UP_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
sStartupConfig.append (sConfig, actualLen);
// Set antenna tuning configuration if configured.
actualLen = GetStrValue(NAME_PREINIT_DSP_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
sStartupConfig.append (sConfig, actualLen);
if ( GetStrValue ( NAME_NFA_DM_START_UP_VSC_CFG, (char*)nfa_dm_start_up_vsc_cfg, sizeof (nfa_dm_start_up_vsc_cfg) ) )
{
p_nfc_hal_dm_start_up_vsc_cfg = &nfa_dm_start_up_vsc_cfg[0];
ALOGD ( "START_UP_VSC_CFG[0] = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
nfa_dm_start_up_vsc_cfg[0],
nfa_dm_start_up_vsc_cfg[1],
nfa_dm_start_up_vsc_cfg[2],
nfa_dm_start_up_vsc_cfg[3],
nfa_dm_start_up_vsc_cfg[4],
nfa_dm_start_up_vsc_cfg[5],
nfa_dm_start_up_vsc_cfg[6],
nfa_dm_start_up_vsc_cfg[7] );
}
actualLen = GetStrValue(NAME_LPTD_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
{
sLptdConfig.append (sConfig, actualLen);
p_nfc_hal_dm_lptd_cfg = const_cast<UINT8*> (sLptdConfig.getInternalBuffer ());
}
else
{
// Default to not sending any LPTD setting.
p_nfc_hal_dm_lptd_cfg = sDontSendLptd;
}
mayDisableSecureElement (sStartupConfig);
p_nfc_hal_dm_start_up_cfg = const_cast<UINT8*> (sStartupConfig.getInternalBuffer ());
actualLen = GetStrValue(NAME_NFA_DM_PRE_DISCOVERY_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
{
sPreDiscoveryConfig.append (sConfig, actualLen);
mayDisableSecureElement (sPreDiscoveryConfig);
p_nfc_hal_pre_discover_cfg = const_cast<UINT8*> (sPreDiscoveryConfig.getInternalBuffer ());
}
//configure how many secure elements are available for each type of chip
if (p_nfc_hal_cfg->nfc_hal_hci_uicc_support > 0)
{
if ((chipid & BRCM_NFC_GEN_MASK) == BRCM_NFC_20791_GEN)
{
nfc_hal_cb.max_ee = BRCM_NFC_20791_GEN_MAX_EE;
p_nfc_hal_cfg->nfc_hal_hci_uicc_support = HAL_NFC_HCI_UICC0_HOST | HAL_NFC_HCI_UICC1_HOST;
}
else if ((chipid & BRCM_NFC_GEN_MASK) == BRCM_NFC_43341_GEN)
{
nfc_hal_cb.max_ee = BRCM_NFC_43341_GEN_MAX_EE;
p_nfc_hal_cfg->nfc_hal_hci_uicc_support = HAL_NFC_HCI_UICC0_HOST | HAL_NFC_HCI_UICC1_HOST;
}
else if ((chipid & BRCM_NFC_GEN_MASK) == BRCM_NFC_20795_GEN)
{
nfc_hal_cb.max_ee = BRCM_NFC_20795_GEN_MAX_EE;
p_nfc_hal_cfg->nfc_hal_hci_uicc_support = HAL_NFC_HCI_UICC0_HOST | HAL_NFC_HCI_UICC1_HOST | HAL_NFC_HCI_UICC2_HOST;
}
//let .conf variable determine how many EE's to discover
if (GetNumValue(NAME_NFA_MAX_EE_SUPPORTED, &num, sizeof(num)))
nfc_hal_cb.max_ee = num;
}
}
/*****************************************************************************************
**
** Function nfc_task_get_nfcc_info
**
** Description Recieves nfcc information coming from nfcc and forward it further to
** to nfc service.
**
** Returns nothing
**
*****************************************************************************************/
void nfc_task_get_nfcc_info(BT_HDR *p_msg)
{
UINT8 *p = NULL;
tNFC_RESPONSE *nfcc_res = NULL;
UINT32 nfcc_version;
NFC_TRACE_DEBUG0 ("nfc_task_get_nfcc_info()");
if(p_msg == NULL)
{
NFC_TRACE_DEBUG0 ("NFCC info null");
return;
}
NFC_TRACE_DEBUG0 ("Sending NFCC info");
p = (UINT8 *) (p_msg + 1) + p_msg->offset;
nfa_dm_cb.nfcc_version = p[NFCC_CHIP_VERSION_OFFSET];
switch(nfa_dm_cb.nfcc_version)
{
case NFCC_V_20:
break;
case NFCC_V_21:
break;
case NFCC_V_24:
break;
case NFCC_V_30:
break;
default:
NFC_TRACE_DEBUG0 ("Wrong nfcc version.Read from conf file");
GetNumValue("NFCC_VERSION", &nfcc_version, sizeof(nfcc_version));
if(nfcc_version)
{
nfa_dm_cb.nfcc_version = nfcc_version;
}
else
{
/*default 3.0*/
nfa_dm_cb.nfcc_version = NFCC_V_30;
}
break;
}
NFC_TRACE_DEBUG1 ("nfa_dm_cb.nfcc_version = %d",nfa_dm_cb.nfcc_version);
nfcc_res = (tNFC_RESPONSE*)malloc(sizeof(tNFC_RESPONSE));
if(nfcc_res != NULL)
{
nfcc_res->nfcc_info_data.len = p_msg->len;
nfcc_res->nfcc_info_data.value = (UINT8*)malloc( nfcc_res->nfcc_info_data.len);
if(nfcc_res->nfcc_info_data.value != NULL)
{
if(nfcc_res->nfcc_info_data.len != 0)
{
memcpy(nfcc_res->nfcc_info_data.value,p,nfcc_res->nfcc_info_data.len);
if (nfc_cb.p_resp_cback)
{
(*nfc_cb.p_resp_cback) (NFC_NFCC_INFO_REVT, nfcc_res);
}
}
/*free acquired mem*/
free(nfcc_res->nfcc_info_data.value);
nfcc_res->nfcc_info_data.value = NULL;
}
else
{
NFC_TRACE_DEBUG0 ("Memory allocation failed");
}
/*free acquired mem*/
free(nfcc_res);
nfcc_res = NULL;
}
else
{
NFC_TRACE_DEBUG0 ("Memory allocation failed for nfcc_res");
}
}
