halimpl/bcm2079x/adaptation/patchram.cpp - platform/external/libnfc-nci - Git at Google

 /******************************************************************************
  *
  *  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 <string>
 #include "spdhelper.h"

 #define LOG_TAG "NfcNciHal"

 /* Location of patchfiles */
 #ifndef NFCA_PATCHFILE_LOCATION
 #define NFCA_PATCHFILE_LOCATION ("/system/vendor/firmware/")
 #endif

 #define FW_PRE_PATCH                        "FW_PRE_PATCH"
 #define FW_PATCH                            "FW_PATCH"
 #define NFA_CONFIG_FORMAT                   "NFA_CONFIG_FORMAT"
 #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 NFA_DM_START_UP_CFG_PARAM_MAX_LEN   100
 static UINT8 nfa_dm_start_up_cfg[NFA_DM_START_UP_CFG_PARAM_MAX_LEN];
 extern UINT8 *p_nfc_hal_dm_start_up_cfg;
 static UINT8 nfa_dm_start_up_vsc_cfg[NFA_DM_START_UP_CFG_PARAM_MAX_LEN];
 extern UINT8 *p_nfc_hal_dm_start_up_vsc_cfg;
 extern UINT8 *p_nfc_hal_dm_lptd_cfg;
 static UINT8 nfa_dm_lptd_cfg[LPTD_PARAM_LEN];
 extern tSNOOZE_MODE_CONFIG gSnoozeModeCfg;
 extern BOOLEAN nfc_hal_prm_nvm_required; //true: don't download firmware if controller cannot detect EERPOM
 static void HalNciCallback (tNFC_HAL_NCI_EVT event, UINT16 data_len, UINT8 *p_data);


 tNFC_POST_RESET_CB nfc_post_reset_cb =
 {
     "/vendor/firmware/bcm2079x_firmware.ncd",
     NULL,
     "/vendor/firmware/bcm2079x_pre_firmware.ncd",
     NULL,
     NFC_HAL_DEFAULT_BAUD,

     {0, 0},                     /* tBRCM_DEV_INIT_CONFIG dev_init_config */

     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  */
 };


 /*******************************************************************************
 **
 ** 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;
 }

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

     if (status != HAL_NFC_STATUS_OK)
     {
         ALOGE("Patch download failed");
         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 */
             USERIAL_PowerupDevice(0);
             HAL_NfcPreInitDone (HAL_NFC_STATUS_OK);
         }
     }
     /* 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()
 {
     unsigned long num;

     if ( GetStrValue ( NAME_NFA_DM_START_UP_CFG, (char*)nfa_dm_start_up_cfg, sizeof ( nfa_dm_start_up_cfg ) ) )
     {
         p_nfc_hal_dm_start_up_cfg = &nfa_dm_start_up_cfg[0];
         ALOGD ( "START_UP_CFG[0] = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
                                                                             nfa_dm_start_up_cfg[0],
                                                                             nfa_dm_start_up_cfg[1],
                                                                             nfa_dm_start_up_cfg[2],
                                                                             nfa_dm_start_up_cfg[3],
                                                                             nfa_dm_start_up_cfg[4],
                                                                             nfa_dm_start_up_cfg[5],
                                                                             nfa_dm_start_up_cfg[6],
                                                                             nfa_dm_start_up_cfg[7] );
     }
     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] );
     }
     if ( GetStrValue ( NAME_LPTD_CFG, (char*)&nfa_dm_lptd_cfg[0], sizeof( nfa_dm_lptd_cfg ) ) )
         p_nfc_hal_dm_lptd_cfg = &nfa_dm_lptd_cfg[0];
 }

 /*******************************************************************************
 **
 ** 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();                 // 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)
                 {
                     fread(sI2cFixPrmBuf, lenPrmBuffer, 1, fd);

                     ALOGD("%s Setting I2C fix to %s (size: %lu)", __FUNCTION__, sPrePatchFn, lenPrmBuffer);
                     HAL_NfcPrmSetI2cPatch((UINT8*)sI2cFixPrmBuf, (UINT16)lenPrmBuffer, 0);
                 }
                 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);
                 tNFC_HAL_PRM_FORMAT patch_format = NFC_HAL_PRM_FORMAT_NCD;

                 GetNumValue((char*)NFA_CONFIG_FORMAT, &patch_format, sizeof(patch_format));

                 ALOGD("%s Downloading patchfile %s (size: %lu) format=%u", __FUNCTION__, sPatchFn, lenPrmBuffer, patch_format);
                 if ((sPrmBuf = malloc(lenPrmBuffer)) != NULL)
                 {
                     fread(sPrmBuf, lenPrmBuffer, 1, fd);

                     if (!SpdHelper::isPatchBad((UINT8*)sPrmBuf, lenPrmBuffer))
                     {
                         /* Download patch using static memeory mode */
                         HAL_NfcPrmDownloadStart(patch_format, 0, (UINT8*)sPrmBuf, lenPrmBuffer, 0, prmCallback);
                         bDownloadStarted = true;
                     }
                 }
                 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%x, nvm_type=%d", __FUNCTION__, brcm_hw_id, nvm_type);
     tHAL_NFC_STATUS stat = HAL_NFC_STATUS_FAILED;
     UINT8 max_credits = 1;

     if (nvm_type == NCI_SPD_NVM_TYPE_NONE)
     {
         ALOGD("%s: No NVM detected, FAIL the init stage to force a retry", __FUNCTION__);
         USERIAL_PowerupDevice (0);
         stat = HAL_NfcReInit (HalNciCallback);
     }
     else
     {
         /* 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:    HalNciCallback
 **
 ** Description: Determine whether controller has detected EEPROM.
 **
 ** Returns:     none
 **
 *******************************************************************************/
 void HalNciCallback (tNFC_HAL_NCI_EVT event, UINT16 dataLen, UINT8* data)
 {
     ALOGD ("%s: enter; event=%X; data len=%u", __FUNCTION__, event, dataLen);
     if (event == NFC_VS_GET_PATCH_VERSION_EVT)
     {
         if (dataLen <= NCI_GET_PATCH_VERSION_NVM_OFFSET)
         {
             ALOGE("%s: response too short to detect NVM type", __FUNCTION__);
             HAL_NfcPreInitDone (HAL_NFC_STATUS_FAILED);
         }
         else
         {
             UINT8 nvramType = *(data + NCI_GET_PATCH_VERSION_NVM_OFFSET);
             if (nvramType == NCI_SPD_NVM_TYPE_NONE)
             {
                 //controller did not find EEPROM, so re-initialize
                 ALOGD("%s: no nvram, try again", __FUNCTION__);
                 USERIAL_PowerupDevice (0);
                 HAL_NfcReInit (HalNciCallback);
             }
             else
             {
                 UINT8 max_credits = 1;
                 ALOGD("%s: found nvram", __FUNCTION__, nvramType);
                 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);
                 }
                 HAL_NfcPreInitDone (HAL_NFC_STATUS_OK);
             }
         }
     }
     ALOGD("%s: exit", __FUNCTION__);
 }
	/******************************************************************************
	*
	* 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 <string>
	#include "spdhelper.h"

	#define LOG_TAG "NfcNciHal"

	/* Location of patchfiles */
	#ifndef NFCA_PATCHFILE_LOCATION
	#define NFCA_PATCHFILE_LOCATION ("/system/vendor/firmware/")
	#endif

	#define FW_PRE_PATCH "FW_PRE_PATCH"
	#define FW_PATCH "FW_PATCH"
	#define NFA_CONFIG_FORMAT "NFA_CONFIG_FORMAT"
	#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 NFA_DM_START_UP_CFG_PARAM_MAX_LEN 100
	static UINT8 nfa_dm_start_up_cfg[NFA_DM_START_UP_CFG_PARAM_MAX_LEN];
	extern UINT8 *p_nfc_hal_dm_start_up_cfg;
	static UINT8 nfa_dm_start_up_vsc_cfg[NFA_DM_START_UP_CFG_PARAM_MAX_LEN];
	extern UINT8 *p_nfc_hal_dm_start_up_vsc_cfg;
	extern UINT8 *p_nfc_hal_dm_lptd_cfg;
	static UINT8 nfa_dm_lptd_cfg[LPTD_PARAM_LEN];
	extern tSNOOZE_MODE_CONFIG gSnoozeModeCfg;
	extern BOOLEAN nfc_hal_prm_nvm_required; //true: don't download firmware if controller cannot detect EERPOM
	static void HalNciCallback (tNFC_HAL_NCI_EVT event, UINT16 data_len, UINT8 *p_data);


	tNFC_POST_RESET_CB nfc_post_reset_cb =
	{
	"/vendor/firmware/bcm2079x_firmware.ncd",
	NULL,
	"/vendor/firmware/bcm2079x_pre_firmware.ncd",
	NULL,
	NFC_HAL_DEFAULT_BAUD,

	{0, 0}, /* tBRCM_DEV_INIT_CONFIG dev_init_config */

	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 */
	};


	/*******************************************************************************
	**
	** 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;
	}

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

	if (status != HAL_NFC_STATUS_OK)
	{
	ALOGE("Patch download failed");
	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 */
	USERIAL_PowerupDevice(0);
	HAL_NfcPreInitDone (HAL_NFC_STATUS_OK);
	}
	}
	/* 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()
	{
	unsigned long num;

	if ( GetStrValue ( NAME_NFA_DM_START_UP_CFG, (char*)nfa_dm_start_up_cfg, sizeof ( nfa_dm_start_up_cfg ) ) )
	{
	p_nfc_hal_dm_start_up_cfg = &nfa_dm_start_up_cfg[0];
	ALOGD ( "START_UP_CFG[0] = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
	nfa_dm_start_up_cfg[0],
	nfa_dm_start_up_cfg[1],
	nfa_dm_start_up_cfg[2],
	nfa_dm_start_up_cfg[3],
	nfa_dm_start_up_cfg[4],
	nfa_dm_start_up_cfg[5],
	nfa_dm_start_up_cfg[6],
	nfa_dm_start_up_cfg[7] );
	}
	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] );
	}
	if ( GetStrValue ( NAME_LPTD_CFG, (char*)&nfa_dm_lptd_cfg[0], sizeof( nfa_dm_lptd_cfg ) ) )
	p_nfc_hal_dm_lptd_cfg = &nfa_dm_lptd_cfg[0];
	}

	/*******************************************************************************
	**
	** 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(); // 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)
	{
	fread(sI2cFixPrmBuf, lenPrmBuffer, 1, fd);

	ALOGD("%s Setting I2C fix to %s (size: %lu)", __FUNCTION__, sPrePatchFn, lenPrmBuffer);
	HAL_NfcPrmSetI2cPatch((UINT8*)sI2cFixPrmBuf, (UINT16)lenPrmBuffer, 0);
	}
	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);
	tNFC_HAL_PRM_FORMAT patch_format = NFC_HAL_PRM_FORMAT_NCD;

	GetNumValue((char*)NFA_CONFIG_FORMAT, &patch_format, sizeof(patch_format));

	ALOGD("%s Downloading patchfile %s (size: %lu) format=%u", __FUNCTION__, sPatchFn, lenPrmBuffer, patch_format);
	if ((sPrmBuf = malloc(lenPrmBuffer)) != NULL)
	{
	fread(sPrmBuf, lenPrmBuffer, 1, fd);

	if (!SpdHelper::isPatchBad((UINT8*)sPrmBuf, lenPrmBuffer))
	{
	/* Download patch using static memeory mode */
	HAL_NfcPrmDownloadStart(patch_format, 0, (UINT8*)sPrmBuf, lenPrmBuffer, 0, prmCallback);
	bDownloadStarted = true;
	}
	}
	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%x, nvm_type=%d", __FUNCTION__, brcm_hw_id, nvm_type);
	tHAL_NFC_STATUS stat = HAL_NFC_STATUS_FAILED;
	UINT8 max_credits = 1;

	if (nvm_type == NCI_SPD_NVM_TYPE_NONE)
	{
	ALOGD("%s: No NVM detected, FAIL the init stage to force a retry", __FUNCTION__);
	USERIAL_PowerupDevice (0);
	stat = HAL_NfcReInit (HalNciCallback);
	}
	else
	{
	/* 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: HalNciCallback
	**
	** Description: Determine whether controller has detected EEPROM.
	**
	** Returns: none
	**
	*******************************************************************************/
	void HalNciCallback (tNFC_HAL_NCI_EVT event, UINT16 dataLen, UINT8* data)
	{
	ALOGD ("%s: enter; event=%X; data len=%u", __FUNCTION__, event, dataLen);
	if (event == NFC_VS_GET_PATCH_VERSION_EVT)
	{
	if (dataLen <= NCI_GET_PATCH_VERSION_NVM_OFFSET)
	{
	ALOGE("%s: response too short to detect NVM type", __FUNCTION__);
	HAL_NfcPreInitDone (HAL_NFC_STATUS_FAILED);
	}
	else
	{
	UINT8 nvramType = *(data + NCI_GET_PATCH_VERSION_NVM_OFFSET);
	if (nvramType == NCI_SPD_NVM_TYPE_NONE)
	{
	//controller did not find EEPROM, so re-initialize
	ALOGD("%s: no nvram, try again", __FUNCTION__);
	USERIAL_PowerupDevice (0);
	HAL_NfcReInit (HalNciCallback);
	}
	else
	{
	UINT8 max_credits = 1;
	ALOGD("%s: found nvram", __FUNCTION__, nvramType);
	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);
	}
	HAL_NfcPreInitDone (HAL_NFC_STATUS_OK);
	}
	}
	}
	ALOGD("%s: exit", __FUNCTION__);
	}