621 lines
22 KiB
C++
621 lines
22 KiB
C++
/******************************************************************************
|
|
*
|
|
* Copyright (C) 1999-2012 Broadcom Corporation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
******************************************************************************/
|
|
#include "OverrideLog.h"
|
|
#include "config.h"
|
|
#include "nfc_hal_int.h"
|
|
#include "userial.h"
|
|
extern "C"
|
|
{
|
|
#include "nfc_hal_post_reset.h"
|
|
}
|
|
#include <malloc.h>
|
|
#include <string>
|
|
#include <cutils/properties.h>
|
|
#include "spdhelper.h"
|
|
#include "StartupConfig.h"
|
|
|
|
#define LOG_TAG "NfcNciHal"
|
|
|
|
#define FW_PRE_PATCH "FW_PRE_PATCH"
|
|
#define FW_PATCH "FW_PATCH"
|
|
#define MAX_RF_DATA_CREDITS "MAX_RF_DATA_CREDITS"
|
|
|
|
#define MAX_BUFFER (512)
|
|
static char sPrePatchFn[MAX_BUFFER+1];
|
|
static char sPatchFn[MAX_BUFFER+1];
|
|
static void * sPrmBuf = NULL;
|
|
static void * sI2cFixPrmBuf = NULL;
|
|
|
|
#define CONFIG_MAX_LEN 256
|
|
static UINT8 sConfig [CONFIG_MAX_LEN];
|
|
static StartupConfig sStartupConfig;
|
|
static StartupConfig sLptdConfig;
|
|
static StartupConfig sPreDiscoveryConfig;
|
|
static StartupConfig sXtalCustomParam;
|
|
extern UINT8 *p_nfc_hal_dm_start_up_cfg; //defined in the HAL
|
|
static UINT8 nfa_dm_start_up_vsc_cfg[CONFIG_MAX_LEN];
|
|
extern UINT8 *p_nfc_hal_dm_start_up_vsc_cfg; //defined in the HAL
|
|
extern UINT8 *p_nfc_hal_dm_lptd_cfg; //defined in the HAL
|
|
static UINT8 sDontSendLptd[] = { 0 };
|
|
extern UINT8 *p_nfc_hal_pre_discover_cfg; //defined in the HAL
|
|
extern UINT8 *p_nfc_hal_dm_xtal_params_cfg; //defined in HAL
|
|
|
|
extern tSNOOZE_MODE_CONFIG gSnoozeModeCfg;
|
|
extern tNFC_HAL_CFG *p_nfc_hal_cfg;
|
|
static void mayDisableSecureElement (StartupConfig& config);
|
|
|
|
/* Default patchfile (in NCD format) */
|
|
#ifndef NFA_APP_DEFAULT_PATCHFILE_NAME
|
|
#define NFA_APP_DEFAULT_PATCHFILE_NAME "\0"
|
|
#endif
|
|
|
|
/* Default patchfile (in NCD format) */
|
|
#ifndef NFA_APP_DEFAULT_I2C_PATCHFILE_NAME
|
|
#define NFA_APP_DEFAULT_I2C_PATCHFILE_NAME "\0"
|
|
#endif
|
|
|
|
tNFC_POST_RESET_CB nfc_post_reset_cb =
|
|
{
|
|
/* Default Patch & Pre-Patch */
|
|
NFA_APP_DEFAULT_PATCHFILE_NAME,
|
|
NULL,
|
|
NFA_APP_DEFAULT_I2C_PATCHFILE_NAME,
|
|
NULL,
|
|
|
|
/* Default UART baud rate */
|
|
NFC_HAL_DEFAULT_BAUD,
|
|
|
|
/* Default tNFC_HAL_DEV_INIT_CFG (flags, num_xtal_cfg, {brcm_hw_id, xtal-freq, xtal-index} ) */
|
|
{
|
|
2, /* number of valid entries */
|
|
{
|
|
{0x43341000, 37400, NFC_HAL_XTAL_INDEX_37400}, // All revisions of 43341 use 37,400
|
|
{0x20795000, 26000, NFC_HAL_XTAL_INDEX_26000},
|
|
{0, 0, 0},
|
|
{0, 0, 0},
|
|
{0, 0, 0},
|
|
}
|
|
},
|
|
|
|
/* Default low power mode settings */
|
|
NFC_HAL_LP_SNOOZE_MODE_NONE, /* Snooze Mode */
|
|
NFC_HAL_LP_IDLE_THRESHOLD_HOST, /* Idle Threshold Host */
|
|
NFC_HAL_LP_IDLE_THRESHOLD_HC, /* Idle Threshold HC */
|
|
NFC_HAL_LP_ACTIVE_LOW, /* NFC_WAKE Active Mode */
|
|
NFC_HAL_LP_ACTIVE_HIGH, /* DH_WAKE Active Mode */
|
|
|
|
NFA_APP_MAX_NUM_REINIT, /* max retry to get NVM type */
|
|
0, /* current retry count */
|
|
TRUE, /* debug mode for downloading patchram */
|
|
FALSE /* skip downloading patchram after reinit because of patch download failure */
|
|
};
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function getFileLength
|
|
**
|
|
** Description return the size of a file
|
|
**
|
|
** Returns file size in number of bytes
|
|
**
|
|
*******************************************************************************/
|
|
static long getFileLength(FILE* fp)
|
|
{
|
|
long sz;
|
|
fseek(fp, 0L, SEEK_END);
|
|
sz = ftell(fp);
|
|
fseek(fp, 0L, SEEK_SET);
|
|
|
|
return (sz > 0) ? sz : 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function isFileExist
|
|
**
|
|
** Description Check if file name exists (android does not support fexists)
|
|
**
|
|
** Returns TRUE if file exists
|
|
**
|
|
*******************************************************************************/
|
|
static BOOLEAN isFileExist(const char *pFilename)
|
|
{
|
|
FILE *pf;
|
|
|
|
if ((pf = fopen(pFilename, "r")) != NULL)
|
|
{
|
|
fclose(pf);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function findPatchramFile
|
|
**
|
|
** Description Find the patchram file name specified in the .conf
|
|
**
|
|
** Returns pointer to the file name
|
|
**
|
|
*******************************************************************************/
|
|
static const char* findPatchramFile(const char * pConfigName, char * pBuffer, int bufferLen)
|
|
{
|
|
ALOGD("%s: config=%s", __FUNCTION__, pConfigName);
|
|
|
|
if (pConfigName == NULL)
|
|
{
|
|
ALOGD("%s No patchfile defined\n", __FUNCTION__);
|
|
return NULL;
|
|
}
|
|
|
|
if (GetStrValue(pConfigName, &pBuffer[0], bufferLen))
|
|
{
|
|
ALOGD("%s found patchfile %s\n", __FUNCTION__, pBuffer);
|
|
return (pBuffer[0] == '\0') ? NULL : pBuffer;
|
|
}
|
|
|
|
ALOGD("%s Cannot find patchfile '%s'\n", __FUNCTION__, pConfigName);
|
|
return NULL;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function: continueAfterSetSnoozeMode
|
|
**
|
|
** Description: Called after Snooze Mode is enabled.
|
|
**
|
|
** Returns: none
|
|
**
|
|
*******************************************************************************/
|
|
static void continueAfterSetSnoozeMode(tHAL_NFC_STATUS status)
|
|
{
|
|
ALOGD("%s: status=%u", __FUNCTION__, status);
|
|
//let stack download firmware during next initialization
|
|
nfc_post_reset_cb.spd_skip_on_power_cycle = FALSE;
|
|
if (status == NCI_STATUS_OK)
|
|
HAL_NfcPreInitDone (HAL_NFC_STATUS_OK);
|
|
else
|
|
HAL_NfcPreInitDone (HAL_NFC_STATUS_FAILED);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function: postDownloadPatchram
|
|
**
|
|
** Description: Called after patch download
|
|
**
|
|
** Returns: none
|
|
**
|
|
*******************************************************************************/
|
|
static void postDownloadPatchram(tHAL_NFC_STATUS status)
|
|
{
|
|
ALOGD("%s: status=%i", __FUNCTION__, status);
|
|
GetStrValue (NAME_SNOOZE_MODE_CFG, (char*)&gSnoozeModeCfg, sizeof(gSnoozeModeCfg));
|
|
if (status != HAL_NFC_STATUS_OK)
|
|
{
|
|
ALOGE("%s: Patch download failed", __FUNCTION__);
|
|
if (status == HAL_NFC_STATUS_REFUSED)
|
|
{
|
|
SpdHelper::setPatchAsBad();
|
|
}
|
|
else
|
|
SpdHelper::incErrorCount();
|
|
|
|
/* If in SPD Debug mode, fail immediately and obviously */
|
|
if (SpdHelper::isSpdDebug())
|
|
HAL_NfcPreInitDone (HAL_NFC_STATUS_FAILED);
|
|
else
|
|
{
|
|
/* otherwise, power cycle the chip and let the stack startup normally */
|
|
ALOGD("%s: re-init; don't download firmware", __FUNCTION__);
|
|
//stop stack from downloading firmware during next initialization
|
|
nfc_post_reset_cb.spd_skip_on_power_cycle = TRUE;
|
|
USERIAL_PowerupDevice(0);
|
|
HAL_NfcReInit ();
|
|
}
|
|
}
|
|
/* Set snooze mode here */
|
|
else if (gSnoozeModeCfg.snooze_mode != NFC_HAL_LP_SNOOZE_MODE_NONE)
|
|
{
|
|
status = HAL_NfcSetSnoozeMode(gSnoozeModeCfg.snooze_mode,
|
|
gSnoozeModeCfg.idle_threshold_dh,
|
|
gSnoozeModeCfg.idle_threshold_nfcc,
|
|
gSnoozeModeCfg.nfc_wake_active_mode,
|
|
gSnoozeModeCfg.dh_wake_active_mode,
|
|
continueAfterSetSnoozeMode);
|
|
if (status != NCI_STATUS_OK)
|
|
{
|
|
ALOGE("%s: Setting snooze mode failed, status=%i", __FUNCTION__, status);
|
|
HAL_NfcPreInitDone(HAL_NFC_STATUS_FAILED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ALOGD("%s: Not using Snooze Mode", __FUNCTION__);
|
|
HAL_NfcPreInitDone(HAL_NFC_STATUS_OK);
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function: prmCallback
|
|
**
|
|
** Description: Patchram callback (for static patchram mode)
|
|
**
|
|
** Returns: none
|
|
**
|
|
*******************************************************************************/
|
|
void prmCallback(UINT8 event)
|
|
{
|
|
ALOGD("%s: event=0x%x", __FUNCTION__, event);
|
|
switch (event)
|
|
{
|
|
case NFC_HAL_PRM_CONTINUE_EVT:
|
|
/* This event does not occur if static patchram buf is used */
|
|
break;
|
|
|
|
case NFC_HAL_PRM_COMPLETE_EVT:
|
|
postDownloadPatchram(HAL_NFC_STATUS_OK);
|
|
break;
|
|
|
|
case NFC_HAL_PRM_ABORT_EVT:
|
|
postDownloadPatchram(HAL_NFC_STATUS_FAILED);
|
|
break;
|
|
|
|
case NFC_HAL_PRM_ABORT_INVALID_PATCH_EVT:
|
|
ALOGD("%s: invalid patch...skipping patch download", __FUNCTION__);
|
|
postDownloadPatchram(HAL_NFC_STATUS_REFUSED);
|
|
break;
|
|
|
|
case NFC_HAL_PRM_ABORT_BAD_SIGNATURE_EVT:
|
|
ALOGD("%s: patch authentication failed", __FUNCTION__);
|
|
postDownloadPatchram(HAL_NFC_STATUS_REFUSED);
|
|
break;
|
|
|
|
case NFC_HAL_PRM_ABORT_NO_NVM_EVT:
|
|
ALOGD("%s: No NVM detected", __FUNCTION__);
|
|
HAL_NfcPreInitDone(HAL_NFC_STATUS_FAILED);
|
|
break;
|
|
|
|
default:
|
|
ALOGD("%s: not handled event=0x%x", __FUNCTION__, event);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** 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 StartPatchDownload
|
|
**
|
|
** Description Reads configuration settings, and begins the download
|
|
** process if patch files are configured.
|
|
**
|
|
** Returns: None
|
|
**
|
|
*******************************************************************************/
|
|
static void StartPatchDownload(UINT32 chipid)
|
|
{
|
|
ALOGD ("%s: chipid=%lx",__FUNCTION__, chipid);
|
|
|
|
char chipID[30];
|
|
sprintf(chipID, "%lx", chipid);
|
|
ALOGD ("%s: chidId=%s", __FUNCTION__, chipID);
|
|
|
|
readOptionalConfig(chipID); // Read optional chip specific settings
|
|
readOptionalConfig("fime"); // Read optional FIME specific settings
|
|
getNfaValues(chipid); // Get NFA configuration values into variables
|
|
|
|
findPatchramFile(FW_PATCH, sPatchFn, sizeof(sPatchFn));
|
|
findPatchramFile(FW_PRE_PATCH, sPrePatchFn, sizeof(sPatchFn));
|
|
|
|
{
|
|
FILE *fd;
|
|
/* If an I2C fix patch file was specified, then tell the stack about it */
|
|
if (sPrePatchFn[0] != '\0')
|
|
{
|
|
if ((fd = fopen(sPrePatchFn, "rb")) != NULL)
|
|
{
|
|
UINT32 lenPrmBuffer = getFileLength(fd);
|
|
|
|
if ((sI2cFixPrmBuf = malloc(lenPrmBuffer)) != NULL)
|
|
{
|
|
size_t actualLen = fread(sI2cFixPrmBuf, 1, lenPrmBuffer, fd);
|
|
if (actualLen == lenPrmBuffer)
|
|
{
|
|
ALOGD("%s Setting I2C fix to %s (size: %lu)", __FUNCTION__, sPrePatchFn, lenPrmBuffer);
|
|
HAL_NfcPrmSetI2cPatch((UINT8*)sI2cFixPrmBuf, (UINT16)lenPrmBuffer, 0);
|
|
}
|
|
else
|
|
ALOGE("%s fail reading i2c fix; actual len=%u; expected len=%lu", __FUNCTION__, actualLen, lenPrmBuffer);
|
|
}
|
|
else
|
|
{
|
|
ALOGE("%s Unable to get buffer to i2c fix (%lu bytes)", __FUNCTION__, lenPrmBuffer);
|
|
}
|
|
|
|
fclose(fd);
|
|
}
|
|
else
|
|
{
|
|
ALOGE("%s Unable to open i2c fix patchfile %s", __FUNCTION__, sPrePatchFn);
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
FILE *fd;
|
|
|
|
/* If a patch file was specified, then download it now */
|
|
if (sPatchFn[0] != '\0')
|
|
{
|
|
UINT32 bDownloadStarted = false;
|
|
|
|
/* open patchfile, read it into a buffer */
|
|
if ((fd = fopen(sPatchFn, "rb")) != NULL)
|
|
{
|
|
UINT32 lenPrmBuffer = getFileLength(fd);
|
|
ALOGD("%s Downloading patchfile %s (size: %lu) format=%u", __FUNCTION__, sPatchFn, lenPrmBuffer, NFC_HAL_PRM_FORMAT_NCD);
|
|
if ((sPrmBuf = malloc(lenPrmBuffer)) != NULL)
|
|
{
|
|
size_t actualLen = fread(sPrmBuf, 1, lenPrmBuffer, fd);
|
|
if (actualLen == lenPrmBuffer)
|
|
{
|
|
if (!SpdHelper::isPatchBad((UINT8*)sPrmBuf, lenPrmBuffer))
|
|
{
|
|
/* Download patch using static memeory mode */
|
|
HAL_NfcPrmDownloadStart(NFC_HAL_PRM_FORMAT_NCD, 0, (UINT8*)sPrmBuf, lenPrmBuffer, 0, prmCallback);
|
|
bDownloadStarted = true;
|
|
}
|
|
}
|
|
else
|
|
ALOGE("%s fail reading patchram", __FUNCTION__);
|
|
}
|
|
else
|
|
ALOGE("%s Unable to buffer to hold patchram (%lu bytes)", __FUNCTION__, lenPrmBuffer);
|
|
|
|
fclose(fd);
|
|
}
|
|
else
|
|
ALOGE("%s Unable to open patchfile %s", __FUNCTION__, sPatchFn);
|
|
|
|
/* If the download never got started */
|
|
if (!bDownloadStarted)
|
|
{
|
|
/* If debug mode, fail in an obvious way, otherwise try to start stack */
|
|
postDownloadPatchram(SpdHelper::isSpdDebug() ? HAL_NFC_STATUS_FAILED :
|
|
HAL_NFC_STATUS_OK);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ALOGE("%s: No patchfile specified or disabled. Proceeding to post-download procedure...", __FUNCTION__);
|
|
postDownloadPatchram(HAL_NFC_STATUS_OK);
|
|
}
|
|
}
|
|
|
|
ALOGD ("%s: exit", __FUNCTION__);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** 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: mayDisableSecureElement
|
|
**
|
|
** Description: Optionally adjust a TLV to disable secure element. This feature
|
|
** is enabled by setting the system property
|
|
** nfc.disable_secure_element to a bit mask represented by a hex
|
|
** octet: C0 = do not detect any secure element.
|
|
** 40 = do not detect secure element in slot 0.
|
|
** 80 = do not detect secure element in slot 1.
|
|
**
|
|
** config: a sequence of TLV's.
|
|
**
|
|
*******************************************************************************/
|
|
void mayDisableSecureElement (StartupConfig& config)
|
|
{
|
|
unsigned int bitmask = 0;
|
|
char valueStr [PROPERTY_VALUE_MAX] = {0};
|
|
int len = property_get ("nfc.disable_secure_element", valueStr, "");
|
|
if (len > 0)
|
|
{
|
|
sscanf (valueStr, "%x", &bitmask); //read system property as a hex octet
|
|
ALOGD ("%s: disable 0x%02X", __FUNCTION__, (UINT8) bitmask);
|
|
config.disableSecureElement ((UINT8) (bitmask & 0xC0));
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** 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;
|
|
}
|