Merge "NfCC power state tracker implementation" into qt-devandroid-mainline-10.0.0_r4android-10.0.0_r9android-10.0.0_r8android-10.0.0_r7android-10.0.0_r45android-10.0.0_r44android-10.0.0_r43android-10.0.0_r42android-10.0.0_r36android-10.0.0_r35android-10.0.0_r34android-10.0.0_r33android-10.0.0_r32android-10.0.0_r31android-10.0.0_r30android-10.0.0_r29android-10.0.0_r28android-10.0.0_r27android-10.0.0_r26android-10.0.0_r25android-10.0.0_r24android-10.0.0_r23android-10.0.0_r22android-10.0.0_r21android-10.0.0_r20android-10.0.0_r19android-10.0.0_r18android-10.0.0_r16android-10.0.0_r15android-10.0.0_r14android-10.0.0_r13android-10.0.0_r12android10-qpr2-s4-releaseandroid10-qpr2-s3-releaseandroid10-qpr2-s2-releaseandroid10-qpr2-s1-releaseandroid10-qpr2-releaseandroid10-qpr1-releaseandroid10-qpr1-mainline-releaseandroid10-qpr1-d-releaseandroid10-qpr1-c-s1-releaseandroid10-qpr1-c-releaseandroid10-qpr1-b-s1-releaseandroid10-qpr1-b-releaseandroid10-mainline-media-releaseandroid10-devandroid10-d4-s1-releaseandroid10-d4-releaseandroid10-c2f2-s2-releaseandroid10-c2f2-s1-releaseandroid10-c2f2-release

6 files changed, 657 insertions, 12 deletions

diff --git a/Android.bp b/Android.bp
index a6cfc1f..7d5d199 100755
--- a/Android.bp
+++ b/Android.bp
@@ -46,6 +46,7 @@ cc_library_shared {
         "halimpl/utils/phNxpConfig.cpp",
         "halimpl/utils/phNxpNciHal_utils.cc",
         "halimpl/utils/sparse_crc32.cc",
+        "halimpl/utils/NfccPowerTracker.cpp",
     ],
 
     local_include_dirs: [
diff --git a/halimpl/hal/phNxpNciHal.cc b/halimpl/hal/phNxpNciHal.cc
index f9d7d2a..7d3264d 100755
--- a/halimpl/hal/phNxpNciHal.cc
+++ b/halimpl/hal/phNxpNciHal.cc
@@ -13,13 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+#include "NfccPowerTracker.h"
+#include "hal_nxpese.h"
+#include "hal_nxpnfc.h"
+#include "spi_spm.h"
+#include <EseAdaptation.h>
+#include <cutils/properties.h>
 #include <log/log.h>
 #include <phDal4Nfc_messageQueueLib.h>
 #include <phDnldNfc.h>
 #include <phNxpConfig.h>
 #include <phNxpLog.h>
-#include <cutils/properties.h>
 #include <phNxpNciHal.h>
 #include <phNxpNciHal_Adaptation.h>
 #include <phNxpNciHal_Dnld.h>
@@ -27,10 +31,6 @@
 #include <phNxpNciHal_ext.h>
 #include <phTmlNfc.h>
 #include <sys/stat.h>
-#include <EseAdaptation.h>
-#include "hal_nxpnfc.h"
-#include "hal_nxpese.h"
-#include "spi_spm.h"
 
 using namespace android::hardware::nfc::V1_1;
 using namespace android::hardware::nfc::V1_2;
@@ -729,7 +729,7 @@ force_download:
       NXPLOG_NCIHAL_D("FW download Success");
     }
   }
-
+  NfccPowerTracker::getInstance().Initialize();
   /* Call open complete */
   phNxpNciHal_MinOpen_complete(wConfigStatus);
   NXPLOG_NCIHAL_D("phNxpNciHal_MinOpen(): exit");
@@ -975,6 +975,9 @@ int phNxpNciHal_write_unlocked(uint16_t data_len, const uint8_t* p_data) {
     goto clean_and_return;
   }
 
+  NfccPowerTracker::getInstance().ProcessCmd(
+      (uint8_t *)nxpncihal_ctrl.p_cmd_data, (uint16_t)nxpncihal_ctrl.cmd_len);
+
 retry:
 
   data_len = nxpncihal_ctrl.cmd_len;
@@ -1108,6 +1111,10 @@ static void phNxpNciHal_read_complete(void* pContext,
 
     phNxpNciHal_print_res_status(pInfo->pBuff, &pInfo->wLength);
 
+    if ((nxpncihal_ctrl.p_rx_data[0x00] & NCI_MT_MASK) == NCI_MT_NTF) {
+      NfccPowerTracker::getInstance().ProcessNtf(nxpncihal_ctrl.p_rx_data,
+                                                 nxpncihal_ctrl.rx_data_len);
+    }
     /* Check if response should go to hal module only */
     if (nxpncihal_ctrl.hal_ext_enabled == TRUE &&
         (nxpncihal_ctrl.p_rx_data[0x00] & NCI_MT_MASK) == NCI_MT_RSP) {
@@ -2154,7 +2161,7 @@ int phNxpNciHal_close(bool bShutdown) {
 
     NXPLOG_NCIHAL_D("phNxpNciHal_close - phOsalNfc_DeInit completed");
   }
-
+  NfccPowerTracker::getInstance().Pause();
   CONCURRENCY_UNLOCK();
 
   phNxpNciHal_cleanup_monitor();
@@ -2198,6 +2205,7 @@ void phNxpNciHal_close_complete(NFCSTATUS status) {
  ******************************************************************************/
 int phNxpNciHal_configDiscShutdown(void) {
   NFCSTATUS status;
+  NfccPowerTracker::getInstance().Reset();
 
   status = phNxpNciHal_close(true);
   if(status != NFCSTATUS_SUCCESS) {
diff --git a/halimpl/libnfc-nxp-PN81B_example_NCI2_0.conf b/halimpl/libnfc-nxp-PN81B_example_NCI2_0.conf
index 03bcb20..d3fbec9 100755
--- a/halimpl/libnfc-nxp-PN81B_example_NCI2_0.conf
+++ b/halimpl/libnfc-nxp-PN81B_example_NCI2_0.conf
@@ -127,7 +127,8 @@ NXP_EXT_TVDD_CFG_2={20, 02, 0F, 01, A0, 0E, 0B, 11, 01, C2, B2, 00, B2, 1E, 1F,
 # DWP intf behavior config, SVDD Load activated by default if set to 0x31 A037
 # SPI CL Sync enable  A098
 # EVT END OF Operation delay A0B2
-NXP_CORE_CONF_EXTN={20, 02, 31, 0C,
+# Power tracker command  A091
+NXP_CORE_CONF_EXTN={20, 02, 35, 0D,
     A0, EC, 01, 01,
     A0, ED, 01, 01,
     A0, 5E, 01, 01,
@@ -139,7 +140,8 @@ NXP_CORE_CONF_EXTN={20, 02, 31, 0C,
     A0, D8, 01, 02,
     A0, D5, 01, 0A,
     A0, 98, 01, 03,
-    A0, B2, 01, 19
+    A0, B2, 01, 19,
+    A0, 91, 01, 01
 }
 
 ###############################################################################
diff --git a/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf b/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf
index c6d81f9..1286368 100755
--- a/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf
+++ b/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf
@@ -127,7 +127,7 @@ NXP_EXT_TVDD_CFG_2={20, 02, 0F, 01, A0, 0E, 0B, 11, 01, C2, B2, 00, B2, 1E, 1F,
 # DWP intf behavior config, SVDD Load activated by default if set to 0x31 A037
 # SPI CL Sync enable  A098
 # EVT END OF Operation delay A0B2
-NXP_CORE_CONF_EXTN={20, 02, 31, 0C,
+NXP_CORE_CONF_EXTN={20, 02, 35, 0D,
     A0, EC, 01, 01,
     A0, ED, 01, 01,
     A0, 5E, 01, 01,
@@ -139,7 +139,8 @@ NXP_CORE_CONF_EXTN={20, 02, 31, 0C,
     A0, D8, 01, 02,
     A0, D5, 01, 0A,
     A0, 98, 01, 03,
-    A0, B2, 01, 19
+    A0, B2, 01, 19,
+    A0, 91, 01, 01
 }
 
 ###############################################################################
diff --git a/halimpl/utils/NfccPowerTracker.cpp b/halimpl/utils/NfccPowerTracker.cpp
new file mode 100644
index 0000000..99f2b8a
--- /dev/null
+++ b/halimpl/utils/NfccPowerTracker.cpp
@@ -0,0 +1,438 @@
+/******************************************************************************
+ *
+ *  Copyright 2018 NXP
+ *
+ *  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.
+ *
+ ******************************************************************************/
+#define LOG_TAG "NfccPowerTracker"
+#include "NfccPowerTracker.h"
+#include "phNxpNciHal_ext.h"
+#include <assert.h>
+#include <fstream>
+#include <iostream>
+#include <log/log.h>
+#include <sstream>
+#include <stdio.h>
+#include <sys/file.h>
+#include <sys/time.h>
+using namespace std;
+
+extern bool nfc_debug_enabled;
+extern phNxpNciHal_Control_t nxpncihal_ctrl;
+static const uint64_t PWR_TRK_ERROR_MARGIN_IN_MILLISEC = 60000;
+static const std::string POWER_TRACKER_LOG_FILE =
+    "/data/vendor/nfc/nfc_power_state.txt";
+static const uint16_t TIMER_COUNT_MASK = 0x7FFF;
+
+NfccPowerTracker::NfccPowerTracker() {
+  mIsFirstPwrTrkNtfRecvd = false;
+  mLastPowerTrackAborted = false;
+  /*Default standby time*/
+  mStandbyTimePerDiscLoopInMillisec = 1000;
+}
+NfccPowerTracker::~NfccPowerTracker() {}
+
+/*******************************************************************************
+**
+** Function         NfccPowerTracker::getInstance
+**
+** Description      access class singleton
+**
+** Returns          pointer to the singleton object
+**
+*******************************************************************************/
+NfccPowerTracker &NfccPowerTracker::getInstance() {
+  static NfccPowerTracker sPwrInstance;
+  return sPwrInstance;
+}
+/*******************************************************************************
+**
+** Function         Initialize
+**
+** Description      get all prerequisite information from NFCC needed for
+**                  Power tracker calculations.
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::Initialize() {
+  /*get total duration of discovery loop from NFCC using GET CONFIG command*/
+  uint8_t cmdGetConfigDiscLoopDuration[] = {0x20, 0x03, 0x02, 0x01, 0x00};
+  int status = phNxpNciHal_send_ext_cmd(sizeof(cmdGetConfigDiscLoopDuration),
+                                        cmdGetConfigDiscLoopDuration);
+  if (status != 0) {
+    ALOGD_IF(nfc_debug_enabled, "NfccPowerTracker::Initialize: failed");
+    return;
+  }
+  /*Check for valid get config response and update stanby time*/
+  if (nxpncihal_ctrl.p_rx_data[0] == 0x40 &&
+      nxpncihal_ctrl.p_rx_data[1] == 0x03 &&
+      nxpncihal_ctrl.p_rx_data[2] == 0x06 &&
+      nxpncihal_ctrl.p_rx_data[3] == 0x00 &&
+      nxpncihal_ctrl.p_rx_data[4] == 0x01 &&
+      nxpncihal_ctrl.p_rx_data[5] == 0x00 &&
+      nxpncihal_ctrl.p_rx_data[6] == 0x02) {
+    mStandbyTimePerDiscLoopInMillisec = (uint32_t)(
+        (nxpncihal_ctrl.p_rx_data[8] << 8) | nxpncihal_ctrl.p_rx_data[7]);
+    ALOGD_IF(nfc_debug_enabled, "mStandbyTimePerDiscLoopInMillisec value : %d",
+             mStandbyTimePerDiscLoopInMillisec);
+  }
+}
+
+/*******************************************************************************
+**
+** Function         TimeDiff
+**
+** Description      Computes time difference in milliseconds.
+**
+** Returns          Time difference in milliseconds
+**
+*******************************************************************************/
+uint64_t NfccPowerTracker::TimeDiff(struct timespec start,
+                                    struct timespec end) {
+  uint64_t startTimeInMillisec =
+      start.tv_sec * 1000 + (start.tv_nsec / 1000000);
+  uint64_t endTimeInMillisec = end.tv_sec * 1000 + (end.tv_nsec / 1000000);
+
+  assert(startTimeInMillisec > endTimeInMillisec);
+  return (endTimeInMillisec - startTimeInMillisec);
+}
+
+/*******************************************************************************
+**
+** Function         NfccPowerTracker::ProcessCmd
+**
+** Description      Parse the commands going to NFCC,
+**                  get the time at which power relevant commands are sent
+**                  (ex:Screen state/OMAPI session)is sent and
+**                  log/cache the timestamp to file
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::ProcessCmd(uint8_t *cmd, uint16_t len) {
+  ALOGD_IF(nfc_debug_enabled,
+           "NfccPowerTracker::ProcessCmd: Enter,Recieved len :%d", len);
+  bool screenStateCommand;
+  if (cmd[0] == 0x20 && cmd[1] == 0x09) {
+    screenStateCommand = true;
+  } else {
+    screenStateCommand = false;
+  }
+
+  if (screenStateCommand && (cmd[3] == 0x00 || cmd[3] == 0x02)) {
+    /* Command for Screen State On-Locked or Unlocked */
+    clock_gettime(CLOCK_BOOTTIME, &mLastScreenOnTimeStamp);
+    mIsLastUpdateScreenOn = true;
+  } else if (screenStateCommand && (cmd[3] == 0x01 || cmd[3] == 0x03)) {
+    /* Command for Screen State OFF-locked or Unlocked */
+    clock_gettime(CLOCK_BOOTTIME, &mLastScreenOffTimeStamp);
+    mIsLastUpdateScreenOn = false;
+  } else if (cmd[0] == 0x20 && cmd[1] == 0x02 && cmd[2] == 0x05 &&
+             cmd[3] == 0x01 && cmd[4] == 0x00 && cmd[5] == 0x02) {
+    /* Command to update duration of discovery loop */
+    mStandbyTimePerDiscLoopInMillisec = (cmd[7] << 8 | cmd[6]);
+    ALOGD_IF(nfc_debug_enabled, "mStandbyTimePerDiscLoopInMillisec value : %d",
+             mStandbyTimePerDiscLoopInMillisec);
+  }
+}
+
+/*******************************************************************************
+**
+** Function         NfccPowerTracker::ProcessNtf
+**
+** Description      Parse the Notifications coming from NFCC,
+**                  get the time at which power relevant notifications are
+**                  received
+**                  (ex:RF ON-OFF/ACTIVATE-DEACTIVATE NTF/PROP_PWR_TRACKINFO)
+**                  calculate error in standby time by comparing the
+**                  expectated value from NFC HAL and received value from NFCC.
+**                  Cache relevant info (timestamps) to file
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::ProcessNtf(uint8_t *rsp, uint16_t rsp_len) {
+  ALOGD_IF(nfc_debug_enabled, "NfccPowerTracker::ProcessNtf: Enter");
+
+  /* Screen State Notification recieved */
+  if ((rsp[0] == 0x6F && rsp[1] == 0x05)) {
+    ProcessPowerTrackNtf(rsp, rsp_len);
+  } else if (rsp[0] == 0x61 && rsp[1] == 0x05) {
+    /*Activation notification received. Calculate the time NFCC is
+    active in Reader/P2P/CE duration */
+    clock_gettime(CLOCK_BOOTTIME, &mActiveTimeStart);
+    if (!mIsLastUpdateScreenOn) {
+      mActiveInfo.totalTransitions++;
+    }
+  } else if (rsp[0] == 0x61 && rsp[1] == 0x06) {
+    /* Deactivation notification received Calculate the time NFCC is
+    active in Reader/P2P/CE duration.Time between Activation and
+    Deacivation gives the active time*/
+    clock_gettime(CLOCK_BOOTTIME, &mActiveTimeEnd);
+    mActiveDurationFromLastScreenUpdate +=
+        TimeDiff(mActiveTimeStart, mActiveTimeEnd);
+    if (!mIsLastUpdateScreenOn) {
+      mStandbyInfo.totalTransitions++;
+    }
+    ALOGD_IF(nfc_debug_enabled, "mActiveDurationFromLastScreenUpdate: %llu",
+             (unsigned long long)mActiveDurationFromLastScreenUpdate);
+  }
+}
+
+/*******************************************************************************
+**
+** Function         ProcessPowerTrackNtf
+**
+** Description      Process Power Tracker notification and update timingInfo to
+**                  Log File.
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::ProcessPowerTrackNtf(uint8_t *rsp, uint16_t rsp_len) {
+  /* Enable Power Tracking computations after 1st Power tracker notification
+   * is received. */
+  if (!mIsFirstPwrTrkNtfRecvd) {
+    mIsFirstPwrTrkNtfRecvd = true;
+    ifstream ifile(POWER_TRACKER_LOG_FILE.c_str());
+    if ((bool)ifile == true) {
+      mLastPowerTrackAborted = true;
+    }
+    return;
+  }
+
+  /*Duration between screen state change is taken as reference for calculating
+  active and standby time*/
+  uint64_t totalDuration = 0;
+  totalDuration =
+      mIsLastUpdateScreenOn
+          ? TimeDiff(mLastScreenOffTimeStamp, mLastScreenOnTimeStamp)
+          : TimeDiff(mLastScreenOnTimeStamp, mLastScreenOffTimeStamp);
+  if (totalDuration == 0)
+    return;
+
+  /*Calculate Active and Standby time based on the pollCount provided in the
+  Power tracker Notification from NFCC*/
+  uint16_t sPollCount = (TIMER_COUNT_MASK & ((rsp[5] << 8) | rsp[4]));
+  ALOGD_IF(nfc_debug_enabled,
+           "Poll/Timer count recived from FW is %d and rsp_len :%d", sPollCount,
+           rsp_len);
+  uint64_t standbyTime = 0, activeTime = 0;
+  if (mIsLastUpdateScreenOn) {
+    activeTime = sPollCount * ACTIVE_TIME_PER_TIMER_COUNT_IN_MILLISEC;
+    /*Check for errors in count provided by NFCC*/
+    uint64_t error = (activeTime > mActiveDurationFromLastScreenUpdate)
+                         ? (activeTime - mActiveDurationFromLastScreenUpdate)
+                         : (mActiveDurationFromLastScreenUpdate - activeTime);
+    if (error > PWR_TRK_ERROR_MARGIN_IN_MILLISEC) {
+      ALOGD_IF(nfc_debug_enabled,
+               "Active Time Error observed with value is %llu",
+               (unsigned long long)error);
+      mErrorInStandbyInfo.residencyInMsecSinceBoot += error;
+    }
+    standbyTime = (totalDuration > activeTime) ? (totalDuration - activeTime)
+                                               : (activeTime - totalDuration);
+    if (rsp[3]) {
+      /*If notification trigger is counter overflow, update the screen on
+      timestamp as there is no screen state change*/
+      clock_gettime(CLOCK_BOOTTIME, &mLastScreenOnTimeStamp);
+    }
+    mActiveInfo.totalTransitions++;
+  } else {
+    standbyTime = (sPollCount * mStandbyTimePerDiscLoopInMillisec);
+    activeTime = totalDuration > standbyTime ? (totalDuration - standbyTime)
+                                             : (standbyTime - totalDuration);
+    if (rsp[3]) {
+      /*If notification trigger is counter overflow, update the screen off
+      timestamp as there is no screen state change*/
+      clock_gettime(CLOCK_BOOTTIME, &mLastScreenOffTimeStamp);
+    }
+    /*Total transitions in screen on -> Screen Off window is same as poll count
+    provided by NFCC, as, there is transition in each discovery loop*/
+    mActiveInfo.totalTransitions += sPollCount;
+    /*1 additional transition for screen state update*/
+    mStandbyInfo.totalTransitions += (sPollCount + 1);
+  }
+
+  ALOGD_IF(nfc_debug_enabled,
+           "activeTime: %llu, standbyTime: %llu, totalDuration :%llu",
+           (unsigned long long)activeTime, (unsigned long long)standbyTime,
+           (unsigned long long)totalDuration);
+  if (mLastPowerTrackAborted) {
+    ALOGD_IF(nfc_debug_enabled,
+             "Last Hal service aborted,so retrive the power info data and "
+             "continue\n");
+    /*Read the file content and store in mActiveInfo.residencyInMsecSinceBoot
+    and mStandbyInfo.residencyInMsecSinceBoot*/
+    if (ReadPowerStateLog()) {
+      mLastPowerTrackAborted = false;
+    }
+  }
+  mStandbyInfo.residencyInMsecSinceBoot += standbyTime;
+  mActiveInfo.residencyInMsecSinceBoot += activeTime;
+  UpdatePowerStateLog(mStandbyInfo, mActiveInfo);
+  mActiveDurationFromLastScreenUpdate = 0;
+}
+/*******************************************************************************
+**
+** Function         NfccPowerTracker::UpdatePowerStateLog
+**
+** Description      update the powerstate related information in log file
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::UpdatePowerStateLog(NfccPowerStateInfo_t mStandbyInfo,
+                                           NfccPowerStateInfo_t mActiveInfo) {
+  FILE *fp;
+  const string PWR_TRK_LOG_FILE_VERSION = "1.0";
+  /*Write the Active and standby timestamp into the file*/
+  fp = fopen(POWER_TRACKER_LOG_FILE.c_str(), "w");
+  if (fp == NULL) {
+    ALOGD_IF(nfc_debug_enabled, "Failed to Open Pwr Tracker Info File\n");
+    return;
+  }
+  ostringstream PwrTrackerInfo;
+  PwrTrackerInfo << "Version: " << PWR_TRK_LOG_FILE_VERSION.c_str() << endl;
+  PwrTrackerInfo << "NFC {" << endl;
+  PwrTrackerInfo << " { " << STR_ACTIVE
+                 << std::to_string(mActiveInfo.residencyInMsecSinceBoot) << " }"
+                 << endl;
+  PwrTrackerInfo << " { " << STR_STANDBY
+                 << std::to_string(mStandbyInfo.residencyInMsecSinceBoot)
+                 << " }" << endl;
+  PwrTrackerInfo << "}";
+  ALOGD_IF(nfc_debug_enabled,
+           "mActiveInfo.residencyInMsecSinceBoot: %llu, "
+           "mActiveInfo.totalTransitions: %llu,"
+           "mStandbyInfo.residencyInMsecSinceBoot "
+           ":%llu,mStandbyInfo.totalTransitions: %llu"
+           "mErrorInStandbyInfo.residencyInMsecSinceBoot: %llu",
+           (unsigned long long)mActiveInfo.residencyInMsecSinceBoot,
+           (unsigned long long)mActiveInfo.totalTransitions,
+           (unsigned long long)mStandbyInfo.residencyInMsecSinceBoot,
+           (unsigned long long)mStandbyInfo.totalTransitions,
+           (unsigned long long)mErrorInStandbyInfo.residencyInMsecSinceBoot);
+  string PwrInfo = PwrTrackerInfo.str();
+  if (!TryLockFile(fp)) {
+    ALOGD_IF(nfc_debug_enabled,
+             "Failed to Lock PwrTracker File.Skipping update\n");
+    fclose(fp);
+    return;
+  }
+  fwrite(PwrInfo.c_str(), sizeof(char), PwrInfo.length(), fp);
+  fflush(fp);
+  UnlockFile(fp);
+  fclose(fp);
+}
+/*******************************************************************************
+ **
+ ** Function         ReadPowerStateLog
+ **
+ ** Description      Retrieve powerstate related information from log file.
+ **
+ ** Returns          true if read successful, false otherwise.
+ **
+ *******************************************************************************/
+bool NfccPowerTracker::ReadPowerStateLog() {
+  ifstream pwrStateFileStream;
+  string itemName;
+  ALOGD_IF(nfc_debug_enabled, "NfccPowerTracker::ReadPowerStateLog: Enter \n");
+  pwrStateFileStream.open(POWER_TRACKER_LOG_FILE.c_str());
+  if (pwrStateFileStream.fail()) {
+    ALOGE("Error: %s", strerror(errno));
+    return false;
+  }
+
+  /*Check for required string(time in millisec) in the log file and convert it
+    to integer*/
+  while (pwrStateFileStream >> itemName) {
+    if (STR_ACTIVE.compare(itemName) == 0) {
+      pwrStateFileStream >> itemName;
+      mActiveInfo.residencyInMsecSinceBoot = stoull(itemName.c_str(), nullptr);
+    } else if (STR_STANDBY.compare(itemName) == 0) {
+      pwrStateFileStream >> itemName;
+      mStandbyInfo.residencyInMsecSinceBoot = stoull(itemName.c_str(), nullptr);
+    }
+  }
+
+  ALOGD_IF(nfc_debug_enabled,
+           "Value retrieved from Powertracker file is"
+           "activeTime: %llu and standbyTime: %llu\n",
+           (unsigned long long)mActiveInfo.residencyInMsecSinceBoot,
+           (unsigned long long)mStandbyInfo.residencyInMsecSinceBoot);
+  pwrStateFileStream.close();
+  return true;
+}
+/*******************************************************************************
+**
+** Function         Pause
+**
+** Description      Pause Power state Information Tracking,Tracking will resume
+**                  once next power tracker notification is recieved as part of
+**                  ProcessNtf.
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::Pause() { mIsFirstPwrTrkNtfRecvd = false; }
+
+/*******************************************************************************
+**
+** Function         Reset
+**
+** Description      Stop power track information processing and delete
+**                  power tracker log file.
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::Reset() {
+  ALOGD_IF(nfc_debug_enabled, "NfccPowerTracker::Reset enter");
+  if (remove(POWER_TRACKER_LOG_FILE.c_str()) != 0) {
+    ALOGD_IF(nfc_debug_enabled, "Error deleting Power tracker file");
+  }
+}
+/*******************************************************************************
+**
+** Function         TryLockFile
+**
+** Description      Lock PowerTracker log file. Any application trying to read
+**                  from PowerTracker log file shall acquire lock before reading
+**                  to avoid inconsistent data.
+**
+** Returns          true if locking was successful
+**                  false if there was a failure to lock PowerTracker log file.
+*******************************************************************************/
+bool NfccPowerTracker::TryLockFile(FILE *fp) {
+  uint8_t retryCount = 5;
+  do {
+    if (!flock(fileno(fp), LOCK_EX | LOCK_NB))
+      return true;
+    usleep(10000); /*10 millisec*/
+  } while (retryCount--);
+
+  return false;
+}
+/*******************************************************************************
+**
+** Function         UnlockFile
+**
+** Description      Unlock previously locked PowerTracker log file.
+**
+** Returns          void
+**
+*******************************************************************************/
+void NfccPowerTracker::UnlockFile(FILE *fp) { flock(fileno(fp), LOCK_UN); }
diff --git a/halimpl/utils/NfccPowerTracker.h b/halimpl/utils/NfccPowerTracker.h
new file mode 100644
index 0000000..3b3e8c0
--- /dev/null
+++ b/halimpl/utils/NfccPowerTracker.h
@@ -0,0 +1,195 @@
+/******************************************************************************
+ *
+ *  Copyright 2018 NXP
+ *
+ *  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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <string>
+#include <time.h>
+#include <vector>
+
+/*Time spent in Active mode per count provided by NFCC*/
+static const uint32_t ACTIVE_TIME_PER_TIMER_COUNT_IN_MILLISEC = 20;
+/*Types of  Power states supported by NFCC */
+typedef struct NfccPowerStateInfo {
+  /* state name: Active/Standby */
+  std::string name;
+  /* Time spent in msec at this  power state since boot */
+  uint64_t residencyInMsecSinceBoot;
+  /* Total number of times Nfcc entered this state */
+  uint64_t totalTransitions;
+} NfccPowerStateInfo_t;
+
+/*Class to track the time spent in Standby mode by NFCC*/
+class NfccPowerTracker {
+public:
+  static NfccPowerTracker &getInstance();
+
+  /*******************************************************************************
+  **
+  ** Function         Initialize
+  **
+  ** Description      get all prerequisite information from NFCC needed for
+  **                  Power tracker calculations.
+  **
+  ** Returns          void
+  **
+  *******************************************************************************/
+  void Initialize();
+
+  /*******************************************************************************
+  **
+  ** Function         ProcessCmd
+  **
+  ** Description      Parse the commands going to NFCC,
+  **                  get the time at which power relevant commands are sent
+  **                  (ex:Screen state/OMAPI session)is sent and
+  **                  log/cache the timestamp to file.
+  **
+  ** Returns          void
+  **
+  *******************************************************************************/
+  void ProcessCmd(uint8_t *, uint16_t len);
+
+  /*******************************************************************************
+  **
+  ** Function         ProcessNtf
+  **
+  ** Description      Parse the Notifications coming from NFCC,
+  **                  get the time at which power relevant notifications are
+  **                  received (ex:RF ON-OFF/ACTIVATE-DEACTIVATE NTF/
+  **                  PROP_PWR_TRACKINFO). Calculate error in standby time by
+  **                  comparing the expectated value from NFC HAL and received
+  **                  value from NFCC. Update power state duration info
+  **                  to file.
+  **
+  ** Returns          void
+  **
+  *******************************************************************************/
+  void ProcessNtf(uint8_t *cmd, uint16_t len);
+
+  /*******************************************************************************
+  **
+  ** Function         Pause
+  **
+  ** Description      Pause Power state Information Tracking,Tracking will
+  **                  resume once next power tracker notification is recieved as
+  **                  part of ProcessNtf.
+  **
+  ** Returns          void
+  **
+  *******************************************************************************/
+  void Pause();
+
+  /*******************************************************************************
+  **
+  ** Function         Reset
+  **
+  ** Description      Stop power tracker information processing and delete
+  **                  power track log file.
+  **
+  ** Returns          void
+  **
+  *******************************************************************************/
+  void Reset();
+
+private:
+  NfccPowerTracker();
+  ~NfccPowerTracker();
+
+  /*******************************************************************************
+  **
+  ** Function         UpdatePowerStateLog
+  **
+  ** Description      update the powerstate related information in log file
+  **
+  ** Returns          void
+  **
+  *******************************************************************************/
+  void UpdatePowerStateLog(NfccPowerStateInfo_t standbyTime,
+                           NfccPowerStateInfo_t activeTime);
+
+  /*******************************************************************************
+   **
+   ** Function         ReadPowerStateLog
+   **
+   ** Description      Retrieve powerstate related information from log file.
+   **
+   ** Returns          true if read successful, false otherwise.
+   **
+   *******************************************************************************/
+  bool ReadPowerStateLog();
+
+  /*******************************************************************************
+   **
+   ** Function         ProcessPowerTrackNtf
+   **
+   ** Description      Process Power Tracker notification.
+   **
+   ** Returns          void
+   **
+   *******************************************************************************/
+  void ProcessPowerTrackNtf(uint8_t *rsp, uint16_t rsp_len);
+
+  /*******************************************************************************
+  **
+  ** Function         TimeDiff
+  **
+  ** Description      Computes time difference in milliseconds.
+  **
+  ** Returns          Time difference in milliseconds
+  **
+  *******************************************************************************/
+  uint64_t TimeDiff(timespec start, timespec end);
+  /*******************************************************************************
+  **
+  ** Function         TryLockFile
+  **
+  ** Description      Lock PowerTracker log file. Any application trying to read
+  **                  from PowerTracker log file shall acquire lock before
+  **                  reading to avoid inconsistent data.
+  **
+  ** Returns          true if locking was successful
+  **                  false if there was a failure to lock file.
+  *******************************************************************************/
+  bool TryLockFile(FILE *fp);
+  /*******************************************************************************
+  **
+  ** Function         UnlockFile
+  **
+  ** Description      Unlock previously locked PowerTracker log file.
+  **
+  ** Returns          void
+  *******************************************************************************/
+  void UnlockFile(FILE *fp);
+  struct timespec mLastScreenOffTimeStamp = {0, 0},
+                  mLastScreenOnTimeStamp = {0, 0};
+  /*Used to calculate time NFCC is active during Card emulation/P2P/Reader
+   * modes*/
+  struct timespec mActiveTimeStart = {0, 0}, mActiveTimeEnd = {0, 0};
+
+  bool mIsLastUpdateScreenOn;
+  bool mIsFirstPwrTrkNtfRecvd;
+
+  uint64_t mActiveDurationFromLastScreenUpdate = 0;
+  NfccPowerStateInfo_t mActiveInfo, mStandbyInfo, mErrorInStandbyInfo;
+
+  /*Last powertracker processing aborted due to NFC HAL Service abort*/
+  bool mLastPowerTrackAborted = false;
+  /* Time spent in standby mode in one discovery loop containing poll */
+  uint32_t mStandbyTimePerDiscLoopInMillisec;
+  const std::string STR_ACTIVE = "Active: ", STR_STANDBY = "StandBy: ";
+};