diff --git a/nci/jni/DataQueue.cpp b/nci/jni/DataQueue.cpp
index c86c36d..1b7193e 100644
--- a/nci/jni/DataQueue.cpp
+++ b/nci/jni/DataQueue.cpp
@@ -81,7 +81,7 @@
 ** Returns:         True if ok.
 **
 *******************************************************************************/
-bool DataQueue::enqueue (UINT8* data, UINT16 dataLen)
+bool DataQueue::enqueue (uint8_t* data, uint16_t dataLen)
 {
     if ((data == NULL) || (dataLen==0))
         return false;
@@ -122,7 +122,7 @@
 ** Returns:         True if ok.
 **
 *******************************************************************************/
-bool DataQueue::dequeue (UINT8* buffer, UINT16 bufferMaxLen, UINT16& actualLen)
+bool DataQueue::dequeue (uint8_t* buffer, uint16_t bufferMaxLen, uint16_t& actualLen)
 {
     mMutex.lock ();
 
diff --git a/nci/jni/DataQueue.h b/nci/jni/DataQueue.h
index bfd415c..b9b9dd6 100644
--- a/nci/jni/DataQueue.h
+++ b/nci/jni/DataQueue.h
@@ -63,7 +63,7 @@
     ** Returns:         True if ok.
     **
     *******************************************************************************/
-    bool enqueue (UINT8* data, UINT16 dataLen);
+    bool enqueue (uint8_t* data, uint16_t dataLen);
 
 
     /*******************************************************************************
@@ -78,7 +78,7 @@
     ** Returns:         True if ok.
     **
     *******************************************************************************/
-    bool dequeue (UINT8* buffer, UINT16 bufferMaxLen, UINT16& actualLen);
+    bool dequeue (uint8_t* buffer, uint16_t bufferMaxLen, uint16_t& actualLen);
 
 
     /*******************************************************************************
@@ -95,8 +95,8 @@
 private:
     struct tHeader
     {
-        UINT16 mDataLen; //number of octets of data
-        UINT16 mOffset; //offset of the first octet of data
+        uint16_t mDataLen; //number of octets of data
+        uint16_t mOffset; //offset of the first octet of data
     };
     typedef std::list<tHeader*> Queue;
 
diff --git a/nci/jni/NativeLlcpConnectionlessSocket.cpp b/nci/jni/NativeLlcpConnectionlessSocket.cpp
index b877acb..2b3cb86 100644
--- a/nci/jni/NativeLlcpConnectionlessSocket.cpp
+++ b/nci/jni/NativeLlcpConnectionlessSocket.cpp
@@ -61,7 +61,7 @@
 *******************************************************************************/
 static jboolean nativeLlcpConnectionlessSocket_doSendTo (JNIEnv *e, jobject o, jint nsap, jbyteArray data)
 {
-    ALOGD ("%s: nsap = %d", __FUNCTION__, nsap);
+    ALOGD ("%s: nsap = %d", __func__, nsap);
 
     ScopedLocalRef<jclass> c(e, e->GetObjectClass(o));
     jfieldID f = e->GetFieldID(c.get(), "mHandle", "I");
@@ -75,13 +75,13 @@
     size_t byte_count = bytes.size();
 
     ALOGD("NFA_P2pSendUI: len = %zu", byte_count);
-    UINT8* raw_ptr = const_cast<UINT8*>(reinterpret_cast<const UINT8*>(&bytes[0])); // TODO: API bug; NFA_P2pSendUI should take const*!
+    uint8_t* raw_ptr = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); // TODO: API bug; NFA_P2pSendUI should take const*!
     tNFA_STATUS status = NFA_P2pSendUI((tNFA_HANDLE) handle, nsap, byte_count, raw_ptr);
 
-    ALOGD("%s: NFA_P2pSendUI done, status = %d", __FUNCTION__, status);
+    ALOGD("%s: NFA_P2pSendUI done, status = %d", __func__, status);
     if (status != NFA_STATUS_OK)
     {
-        ALOGE("%s: NFA_P2pSendUI failed, status = %d", __FUNCTION__, status);
+        ALOGE("%s: NFA_P2pSendUI failed, status = %d", __func__, status);
         return JNI_FALSE;
     }
     return JNI_TRUE;
@@ -102,7 +102,7 @@
 *******************************************************************************/
 void nativeLlcpConnectionlessSocket_receiveData (uint8_t* data, uint32_t len, uint32_t remoteSap)
 {
-    ALOGD ("%s: waiting for data = %d, len = %d", __FUNCTION__, sConnlessRecvWaitingForData, len);
+    ALOGD ("%s: waiting for data = %d, len = %d", __func__, sConnlessRecvWaitingForData, len);
 
     // Sanity...
     if (sConnlessRecvLen < len)
@@ -173,20 +173,20 @@
 *******************************************************************************/
 static jobject nativeLlcpConnectionlessSocket_doReceiveFrom (JNIEnv* e, jobject, jint linkMiu)
 {
-    ALOGD ("%s: linkMiu = %d", __FUNCTION__, linkMiu);
+    ALOGD ("%s: linkMiu = %d", __func__, linkMiu);
     jobject llcpPacket = NULL;
     ScopedLocalRef<jclass> clsLlcpPacket(e, NULL);
 
     if (sConnlessRecvWaitingForData != JNI_FALSE)
     {
-        ALOGD ("%s: Already waiting for incoming data", __FUNCTION__);
+        ALOGD ("%s: Already waiting for incoming data", __func__);
         return NULL;
     }
 
     sConnlessRecvBuf = (uint8_t*) malloc (linkMiu);
     if (sConnlessRecvBuf == NULL)
     {
-        ALOGD ("%s: Failed to allocate %d bytes memory buffer", __FUNCTION__, linkMiu);
+        ALOGD ("%s: Failed to allocate %d bytes memory buffer", __func__, linkMiu);
         return NULL;
     }
     sConnlessRecvLen = linkMiu;
@@ -194,7 +194,7 @@
     // Create the write semaphore
     if (sem_init (&sConnlessRecvSem, 0, 0) == -1)
     {
-        ALOGE ("%s: semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: semaphore creation failed (errno=0x%08x)", __func__, errno);
         return connectionlessCleanup ();
     }
 
@@ -203,14 +203,14 @@
     // Wait for sConnlessRecvSem completion status
     if (sem_wait (&sConnlessRecvSem))
     {
-        ALOGE ("%s: Failed to wait for write semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to wait for write semaphore (errno=0x%08x)", __func__, errno);
         goto TheEnd;
     }
 
     // Create new LlcpPacket object
     if (nfc_jni_cache_object_local (e, "com/android/nfc/LlcpPacket", &(llcpPacket)) == -1)
     {
-        ALOGE ("%s: Find LlcpPacket class error", __FUNCTION__);
+        ALOGE ("%s: Find LlcpPacket class error", __func__);
         return connectionlessCleanup ();
     }
 
@@ -219,7 +219,7 @@
     if (e->ExceptionCheck())
     {
         e->ExceptionClear();
-        ALOGE ("%s: Get Object class error", __FUNCTION__);
+        ALOGE ("%s: Get Object class error", __func__);
         return connectionlessCleanup ();
     }
 
@@ -229,7 +229,7 @@
     e->SetIntField(llcpPacket, f, (jbyte) sConnlessRecvRemoteSap);
 
     // Set Llcp Packet Buffer
-    ALOGD ("%s: Received Llcp packet buffer size = %d\n", __FUNCTION__, sConnlessRecvLen);
+    ALOGD ("%s: Received Llcp packet buffer size = %d\n", __func__, sConnlessRecvLen);
     f = e->GetFieldID(clsLlcpPacket.get(), "mDataBuffer", "[B");
 
     {
@@ -242,7 +242,7 @@
     connectionlessCleanup ();
     if (sem_destroy (&sConnlessRecvSem))
     {
-        ALOGE ("%s: Failed to destroy sConnlessRecvSem semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to destroy sConnlessRecvSem semaphore (errno=0x%08x)", __func__, errno);
     }
     return llcpPacket;
 }
@@ -261,7 +261,7 @@
 *******************************************************************************/
 static jboolean nativeLlcpConnectionlessSocket_doClose (JNIEnv *e, jobject o)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
 
     ScopedLocalRef<jclass> c(e, e->GetObjectClass(o));
     jfieldID f = e->GetFieldID(c.get(), "mHandle", "I");
@@ -270,7 +270,7 @@
     tNFA_STATUS status = NFA_P2pDisconnect((tNFA_HANDLE) handle, FALSE);
     if (status != NFA_STATUS_OK)
     {
-        ALOGE ("%s: disconnect failed, status = %d", __FUNCTION__, status);
+        ALOGE ("%s: disconnect failed, status = %d", __func__, status);
         return JNI_FALSE;
     }
     return JNI_TRUE;
diff --git a/nci/jni/NativeLlcpServiceSocket.cpp b/nci/jni/NativeLlcpServiceSocket.cpp
index ace7ee4..8325fb8 100644
--- a/nci/jni/NativeLlcpServiceSocket.cpp
+++ b/nci/jni/NativeLlcpServiceSocket.cpp
@@ -56,7 +56,7 @@
     bool        stat = false;
     PeerToPeer::tJNI_HANDLE connHandle = PeerToPeer::getInstance().getNewJniHandle ();
 
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     serverHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e, o);
 
@@ -64,14 +64,14 @@
 
     if (! stat)
     {
-        ALOGE ("%s: fail accept", __FUNCTION__);
+        ALOGE ("%s: fail accept", __func__);
         goto TheEnd;
     }
 
     /* Create new LlcpSocket object */
     if (nfc_jni_cache_object_local(e, gNativeLlcpSocketClassName, &(clientSocket)) == -1)
     {
-        ALOGE ("%s: fail create NativeLlcpSocket", __FUNCTION__);
+        ALOGE ("%s: fail create NativeLlcpSocket", __func__);
         goto TheEnd;
     }
 
@@ -80,7 +80,7 @@
     if (e->ExceptionCheck())
     {
         e->ExceptionClear();
-        ALOGE ("%s: get class object error", __FUNCTION__);
+        ALOGE ("%s: get class object error", __func__);
         goto TheEnd;
     }
 
@@ -97,7 +97,7 @@
     e->SetIntField (clientSocket, f, (jint)rw);
 
 TheEnd:
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return clientSocket;
 }
 
@@ -115,7 +115,7 @@
 *******************************************************************************/
 static jboolean nativeLlcpServiceSocket_doClose(JNIEnv *e, jobject o)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     PeerToPeer::tJNI_HANDLE jniServerHandle = 0;
     bool stat = false;
 
@@ -123,7 +123,7 @@
 
     stat = PeerToPeer::getInstance().deregisterServer (jniServerHandle);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return JNI_TRUE;
 }
 
diff --git a/nci/jni/NativeLlcpSocket.cpp b/nci/jni/NativeLlcpSocket.cpp
index bd3964d..395e4f7 100644
--- a/nci/jni/NativeLlcpSocket.cpp
+++ b/nci/jni/NativeLlcpSocket.cpp
@@ -38,12 +38,12 @@
 *******************************************************************************/
 static jboolean nativeLlcpSocket_doConnect (JNIEnv* e, jobject o, jint nSap)
 {
-    ALOGD ("%s: enter; sap=%d", __FUNCTION__, nSap);
+    ALOGD ("%s: enter; sap=%d", __func__, nSap);
 
     PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle(e, o);
     bool stat = PeerToPeer::getInstance().connectConnOriented (jniHandle, nSap);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return stat ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -62,7 +62,7 @@
 *******************************************************************************/
 static jboolean nativeLlcpSocket_doConnectBy (JNIEnv* e, jobject o, jstring sn)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle(e, o);
 
@@ -73,7 +73,7 @@
     }
     bool stat = PeerToPeer::getInstance().connectConnOriented(jniHandle, serviceName.c_str());
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return stat ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -91,12 +91,12 @@
 *******************************************************************************/
 static jboolean nativeLlcpSocket_doClose(JNIEnv *e, jobject o)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle(e, o);
     bool stat = PeerToPeer::getInstance().disconnectConnOriented (jniHandle);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return stat ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -115,15 +115,15 @@
 *******************************************************************************/
 static jboolean nativeLlcpSocket_doSend (JNIEnv* e, jobject o, jbyteArray data)
 {
-    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter", __FUNCTION__);
+    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter", __func__);
 
     ScopedByteArrayRO bytes(e, data);
 
     PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle(e, o);
-    UINT8* raw_ptr = const_cast<UINT8*>(reinterpret_cast<const UINT8*>(&bytes[0])); // TODO: API bug: send should take const*!
+    uint8_t* raw_ptr = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); // TODO: API bug: send should take const*!
     bool stat = PeerToPeer::getInstance().send(jniHandle, raw_ptr, bytes.size());
 
-    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit", __FUNCTION__);
+    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit", __func__);
     return stat ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -142,13 +142,13 @@
 *******************************************************************************/
 static jint nativeLlcpSocket_doReceive(JNIEnv *e, jobject o, jbyteArray origBuffer)
 {
-    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter", __FUNCTION__);
+    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter", __func__);
 
     ScopedByteArrayRW bytes(e, origBuffer);
 
     PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle(e, o);
     uint16_t actualLen = 0;
-    bool stat = PeerToPeer::getInstance().receive(jniHandle, reinterpret_cast<UINT8*>(&bytes[0]), bytes.size(), actualLen);
+    bool stat = PeerToPeer::getInstance().receive(jniHandle, reinterpret_cast<uint8_t*>(&bytes[0]), bytes.size(), actualLen);
 
     jint retval = 0;
     if (stat && (actualLen>0))
@@ -158,7 +158,7 @@
     else
         retval = -1;
 
-    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit; actual len=%d", __FUNCTION__, retval);
+    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit; actual len=%d", __func__, retval);
     return retval;
 }
 
@@ -176,12 +176,12 @@
 *******************************************************************************/
 static jint nativeLlcpSocket_doGetRemoteSocketMIU (JNIEnv* e, jobject o)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle(e, o);
     jint miu = PeerToPeer::getInstance().getRemoteMaxInfoUnit(jniHandle);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return miu;
 }
 
@@ -199,12 +199,12 @@
 *******************************************************************************/
 static jint nativeLlcpSocket_doGetRemoteSocketRW (JNIEnv* e, jobject o)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle(e, o);
     jint rw = PeerToPeer::getInstance().getRemoteRecvWindow (jniHandle);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return rw;
 }
 
diff --git a/nci/jni/NativeNfcManager.cpp b/nci/jni/NativeNfcManager.cpp
index e32b17c..b372801 100755
--- a/nci/jni/NativeNfcManager.cpp
+++ b/nci/jni/NativeNfcManager.cpp
@@ -42,8 +42,8 @@
     #include "phNxpExtns.h"
 }
 
-extern const UINT8 nfca_version_string [];
-extern const UINT8 nfa_version_string [];
+extern const uint8_t nfca_version_string [];
+extern const uint8_t nfa_version_string [];
 extern tNFA_DM_DISC_FREQ_CFG* p_nfa_dm_rf_disc_freq_cfg; //defined in stack
 namespace android
 {
@@ -138,16 +138,16 @@
 #define DEFAULT_DISCOVERY_DURATION       500
 #define READER_MODE_DISCOVERY_DURATION   200
 
-static void nfaConnectionCallback (UINT8 event, tNFA_CONN_EVT_DATA *eventData);
-static void nfaDeviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA *eventData);
+static void nfaConnectionCallback (uint8_t event, tNFA_CONN_EVT_DATA *eventData);
+static void nfaDeviceManagementCallback (uint8_t event, tNFA_DM_CBACK_DATA *eventData);
 static bool isPeerToPeer (tNFA_ACTIVATED& activated);
 static bool isListenMode(tNFA_ACTIVATED& activated);
 static void enableDisableLptd (bool enable);
 static tNFA_STATUS stopPolling_rfDiscoveryDisabled();
 static tNFA_STATUS startPolling_rfDiscoveryDisabled(tNFA_TECHNOLOGY_MASK tech_mask);
 
-static UINT16 sCurrentConfigLen;
-static UINT8 sConfig[256];
+static uint16_t sCurrentConfigLen;
+static uint8_t sConfig[256];
 
 /////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////
@@ -216,16 +216,16 @@
 ** Returns:         None
 **
 *******************************************************************************/
-static void nfaConnectionCallback (UINT8 connEvent, tNFA_CONN_EVT_DATA* eventData)
+static void nfaConnectionCallback (uint8_t connEvent, tNFA_CONN_EVT_DATA* eventData)
 {
     tNFA_STATUS status = NFA_STATUS_FAILED;
-    ALOGD("%s: event= %u", __FUNCTION__, connEvent);
+    ALOGD("%s: event= %u", __func__, connEvent);
 
     switch (connEvent)
     {
     case NFA_POLL_ENABLED_EVT: // whether polling successfully started
         {
-            ALOGD("%s: NFA_POLL_ENABLED_EVT: status = %u", __FUNCTION__, eventData->status);
+            ALOGD("%s: NFA_POLL_ENABLED_EVT: status = %u", __func__, eventData->status);
 
             SyncEventGuard guard (sNfaEnableDisablePollingEvent);
             sNfaEnableDisablePollingEvent.notifyOne ();
@@ -234,7 +234,7 @@
 
     case NFA_POLL_DISABLED_EVT: // Listening/Polling stopped
         {
-            ALOGD("%s: NFA_POLL_DISABLED_EVT: status = %u", __FUNCTION__, eventData->status);
+            ALOGD("%s: NFA_POLL_DISABLED_EVT: status = %u", __func__, eventData->status);
 
             SyncEventGuard guard (sNfaEnableDisablePollingEvent);
             sNfaEnableDisablePollingEvent.notifyOne ();
@@ -243,7 +243,7 @@
 
     case NFA_RF_DISCOVERY_STARTED_EVT: // RF Discovery started
         {
-            ALOGD("%s: NFA_RF_DISCOVERY_STARTED_EVT: status = %u", __FUNCTION__, eventData->status);
+            ALOGD("%s: NFA_RF_DISCOVERY_STARTED_EVT: status = %u", __func__, eventData->status);
 
             SyncEventGuard guard (sNfaEnableDisablePollingEvent);
             sNfaEnableDisablePollingEvent.notifyOne ();
@@ -252,7 +252,7 @@
 
     case NFA_RF_DISCOVERY_STOPPED_EVT: // RF Discovery stopped event
         {
-            ALOGD("%s: NFA_RF_DISCOVERY_STOPPED_EVT: status = %u", __FUNCTION__, eventData->status);
+            ALOGD("%s: NFA_RF_DISCOVERY_STOPPED_EVT: status = %u", __func__, eventData->status);
 
             SyncEventGuard guard (sNfaEnableDisablePollingEvent);
             sNfaEnableDisablePollingEvent.notifyOne ();
@@ -261,10 +261,10 @@
 
     case NFA_DISC_RESULT_EVT: // NFC link/protocol discovery notificaiton
         status = eventData->disc_result.status;
-        ALOGD("%s: NFA_DISC_RESULT_EVT: status = %d", __FUNCTION__, status);
+        ALOGD("%s: NFA_DISC_RESULT_EVT: status = %d", __func__, status);
         if (status != NFA_STATUS_OK)
         {
-            ALOGE("%s: NFA_DISC_RESULT_EVT error: status = %d", __FUNCTION__, status);
+            ALOGE("%s: NFA_DISC_RESULT_EVT error: status = %d", __func__, status);
         }
         else
         {
@@ -274,7 +274,7 @@
         break;
 
     case NFA_SELECT_RESULT_EVT: // NFC link/protocol discovery select response
-        ALOGD("%s: NFA_SELECT_RESULT_EVT: status = %d, gIsSelectingRfInterface = %d, sIsDisabling=%d", __FUNCTION__, eventData->status, gIsSelectingRfInterface, sIsDisabling);
+        ALOGD("%s: NFA_SELECT_RESULT_EVT: status = %d, gIsSelectingRfInterface = %d, sIsDisabling=%d", __func__, eventData->status, gIsSelectingRfInterface, sIsDisabling);
 
         if (sIsDisabling)
             break;
@@ -286,17 +286,17 @@
                 nativeNfcTag_doConnectStatus(false);
             }
 
-            ALOGE("%s: NFA_SELECT_RESULT_EVT error: status = %d", __FUNCTION__, eventData->status);
+            ALOGE("%s: NFA_SELECT_RESULT_EVT error: status = %d", __func__, eventData->status);
             NFA_Deactivate (FALSE);
         }
         break;
 
     case NFA_DEACTIVATE_FAIL_EVT:
-        ALOGD("%s: NFA_DEACTIVATE_FAIL_EVT: status = %d", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_DEACTIVATE_FAIL_EVT: status = %d", __func__, eventData->status);
         break;
 
     case NFA_ACTIVATED_EVT: // NFC link/protocol activated
-        ALOGD("%s: NFA_ACTIVATED_EVT: gIsSelectingRfInterface=%d, sIsDisabling=%d", __FUNCTION__, gIsSelectingRfInterface, sIsDisabling);
+        ALOGD("%s: NFA_ACTIVATED_EVT: gIsSelectingRfInterface=%d, sIsDisabling=%d", __func__, gIsSelectingRfInterface, sIsDisabling);
         if((eventData->activated.activate_ntf.protocol != NFA_PROTOCOL_NFC_DEP) && (!isListenMode (eventData->activated)))
         {
             nativeNfcTag_setRfInterface ((tNFA_INTF_TYPE) eventData->activated.activate_ntf.intf_param.type);
@@ -324,21 +324,21 @@
         {
             if (sReaderModeEnabled)
             {
-                ALOGD("%s: ignoring peer target in reader mode.", __FUNCTION__);
+                ALOGD("%s: ignoring peer target in reader mode.", __func__);
                 NFA_Deactivate (FALSE);
                 break;
             }
             sP2pActive = true;
-            ALOGD("%s: NFA_ACTIVATED_EVT; is p2p", __FUNCTION__);
+            ALOGD("%s: NFA_ACTIVATED_EVT; is p2p", __func__);
             // Disable RF field events in case of p2p
-            UINT8  nfa_disable_rf_events[] = { 0x00 };
-            ALOGD ("%s: Disabling RF field events", __FUNCTION__);
+            uint8_t  nfa_disable_rf_events[] = { 0x00 };
+            ALOGD ("%s: Disabling RF field events", __func__);
             status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_disable_rf_events),
                     &nfa_disable_rf_events[0]);
             if (status == NFA_STATUS_OK) {
-                ALOGD ("%s: Disabled RF field events", __FUNCTION__);
+                ALOGD ("%s: Disabled RF field events", __func__);
             } else {
-                ALOGE ("%s: Failed to disable RF field events", __FUNCTION__);
+                ALOGE ("%s: Failed to disable RF field events", __func__);
             }
         }
         else if (pn544InteropIsBusy() == false)
@@ -356,7 +356,7 @@
         break;
 
     case NFA_DEACTIVATED_EVT: // NFC link/protocol deactivated
-        ALOGD("%s: NFA_DEACTIVATED_EVT   Type: %u, gIsTagDeactivating: %d", __FUNCTION__, eventData->deactivated.type,gIsTagDeactivating);
+        ALOGD("%s: NFA_DEACTIVATED_EVT   Type: %u, gIsTagDeactivating: %d", __func__, eventData->deactivated.type,gIsTagDeactivating);
         NfcTag::getInstance().setDeactivationState (eventData->deactivated);
         if (eventData->deactivated.type != NFA_DEACTIVATE_TYPE_SLEEP)
         {
@@ -391,19 +391,19 @@
             } else if (sP2pActive) {
                 sP2pActive = false;
                 // Make sure RF field events are re-enabled
-                ALOGD("%s: NFA_DEACTIVATED_EVT; is p2p", __FUNCTION__);
+                ALOGD("%s: NFA_DEACTIVATED_EVT; is p2p", __func__);
                 // Disable RF field events in case of p2p
-                UINT8  nfa_enable_rf_events[] = { 0x01 };
+                uint8_t  nfa_enable_rf_events[] = { 0x01 };
 
                 if (!sIsDisabling && sIsNfaEnabled)
                 {
-                    ALOGD ("%s: Enabling RF field events", __FUNCTION__);
+                    ALOGD ("%s: Enabling RF field events", __func__);
                     status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_enable_rf_events),
                             &nfa_enable_rf_events[0]);
                     if (status == NFA_STATUS_OK) {
-                        ALOGD ("%s: Enabled RF field events", __FUNCTION__);
+                        ALOGD ("%s: Enabled RF field events", __func__);
                     } else {
-                        ALOGE ("%s: Failed to enable RF field events", __FUNCTION__);
+                        ALOGE ("%s: Failed to enable RF field events", __func__);
                     }
                 }
             }
@@ -414,11 +414,11 @@
     case NFA_TLV_DETECT_EVT: // TLV Detection complete
         status = eventData->tlv_detect.status;
         ALOGD("%s: NFA_TLV_DETECT_EVT: status = %d, protocol = %d, num_tlvs = %d, num_bytes = %d",
-             __FUNCTION__, status, eventData->tlv_detect.protocol,
+             __func__, status, eventData->tlv_detect.protocol,
              eventData->tlv_detect.num_tlvs, eventData->tlv_detect.num_bytes);
         if (status != NFA_STATUS_OK)
         {
-            ALOGE("%s: NFA_TLV_DETECT_EVT error: status = %d", __FUNCTION__, status);
+            ALOGE("%s: NFA_TLV_DETECT_EVT error: status = %d", __func__, status);
         }
         break;
 
@@ -427,7 +427,7 @@
         //pass the failure status to the NFC Service;
         status = eventData->ndef_detect.status;
         ALOGD("%s: NFA_NDEF_DETECT_EVT: status = 0x%X, protocol = %u, "
-             "max_size = %lu, cur_size = %lu, flags = 0x%X", __FUNCTION__,
+             "max_size = %u, cur_size = %u, flags = 0x%X", __func__,
              status,
              eventData->ndef_detect.protocol, eventData->ndef_detect.max_size,
              eventData->ndef_detect.cur_size, eventData->ndef_detect.flags);
@@ -438,53 +438,53 @@
         break;
 
     case NFA_DATA_EVT: // Data message received (for non-NDEF reads)
-        ALOGD("%s: NFA_DATA_EVT: status = 0x%X, len = %d", __FUNCTION__, eventData->status, eventData->data.len);
+        ALOGD("%s: NFA_DATA_EVT: status = 0x%X, len = %d", __func__, eventData->status, eventData->data.len);
         nativeNfcTag_doTransceiveStatus(eventData->status, eventData->data.p_data, eventData->data.len);
         break;
     case NFA_RW_INTF_ERROR_EVT:
-        ALOGD("%s: NFC_RW_INTF_ERROR_EVT", __FUNCTION__);
+        ALOGD("%s: NFC_RW_INTF_ERROR_EVT", __func__);
         nativeNfcTag_notifyRfTimeout();
         nativeNfcTag_doReadCompleted (NFA_STATUS_TIMEOUT);
         break;
     case NFA_SELECT_CPLT_EVT: // Select completed
         status = eventData->status;
-        ALOGD("%s: NFA_SELECT_CPLT_EVT: status = %d", __FUNCTION__, status);
+        ALOGD("%s: NFA_SELECT_CPLT_EVT: status = %d", __func__, status);
         if (status != NFA_STATUS_OK)
         {
-            ALOGE("%s: NFA_SELECT_CPLT_EVT error: status = %d", __FUNCTION__, status);
+            ALOGE("%s: NFA_SELECT_CPLT_EVT error: status = %d", __func__, status);
         }
         break;
 
     case NFA_READ_CPLT_EVT: // NDEF-read or tag-specific-read completed
-        ALOGD("%s: NFA_READ_CPLT_EVT: status = 0x%X", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_READ_CPLT_EVT: status = 0x%X", __func__, eventData->status);
         nativeNfcTag_doReadCompleted (eventData->status);
         NfcTag::getInstance().connectionEventHandler (connEvent, eventData);
         break;
 
     case NFA_WRITE_CPLT_EVT: // Write completed
-        ALOGD("%s: NFA_WRITE_CPLT_EVT: status = %d", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_WRITE_CPLT_EVT: status = %d", __func__, eventData->status);
         nativeNfcTag_doWriteStatus (eventData->status == NFA_STATUS_OK);
         break;
 
     case NFA_SET_TAG_RO_EVT: // Tag set as Read only
-        ALOGD("%s: NFA_SET_TAG_RO_EVT: status = %d", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_SET_TAG_RO_EVT: status = %d", __func__, eventData->status);
         nativeNfcTag_doMakeReadonlyResult(eventData->status);
         break;
 
     case NFA_CE_NDEF_WRITE_START_EVT: // NDEF write started
-        ALOGD("%s: NFA_CE_NDEF_WRITE_START_EVT: status: %d", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_CE_NDEF_WRITE_START_EVT: status: %d", __func__, eventData->status);
 
         if (eventData->status != NFA_STATUS_OK)
-            ALOGE("%s: NFA_CE_NDEF_WRITE_START_EVT error: status = %d", __FUNCTION__, eventData->status);
+            ALOGE("%s: NFA_CE_NDEF_WRITE_START_EVT error: status = %d", __func__, eventData->status);
         break;
 
     case NFA_CE_NDEF_WRITE_CPLT_EVT: // NDEF write completed
-        ALOGD("%s: FA_CE_NDEF_WRITE_CPLT_EVT: len = %lu", __FUNCTION__, eventData->ndef_write_cplt.len);
+        ALOGD("%s: FA_CE_NDEF_WRITE_CPLT_EVT: len = %u", __func__, eventData->ndef_write_cplt.len);
         break;
 
     case NFA_LLCP_ACTIVATED_EVT: // LLCP link is activated
         ALOGD("%s: NFA_LLCP_ACTIVATED_EVT: is_initiator: %d  remote_wks: %d, remote_lsc: %d, remote_link_miu: %d, local_link_miu: %d",
-             __FUNCTION__,
+             __func__,
              eventData->llcp_activated.is_initiator,
              eventData->llcp_activated.remote_wks,
              eventData->llcp_activated.remote_lsc,
@@ -495,37 +495,37 @@
         break;
 
     case NFA_LLCP_DEACTIVATED_EVT: // LLCP link is deactivated
-        ALOGD("%s: NFA_LLCP_DEACTIVATED_EVT", __FUNCTION__);
+        ALOGD("%s: NFA_LLCP_DEACTIVATED_EVT", __func__);
         PeerToPeer::getInstance().llcpDeactivatedHandler (getNative(0, 0), eventData->llcp_deactivated);
         break;
     case NFA_LLCP_FIRST_PACKET_RECEIVED_EVT: // Received first packet over llcp
-        ALOGD("%s: NFA_LLCP_FIRST_PACKET_RECEIVED_EVT", __FUNCTION__);
+        ALOGD("%s: NFA_LLCP_FIRST_PACKET_RECEIVED_EVT", __func__);
         PeerToPeer::getInstance().llcpFirstPacketHandler (getNative(0, 0));
         break;
     case NFA_PRESENCE_CHECK_EVT:
-        ALOGD("%s: NFA_PRESENCE_CHECK_EVT", __FUNCTION__);
+        ALOGD("%s: NFA_PRESENCE_CHECK_EVT", __func__);
         nativeNfcTag_doPresenceCheckResult (eventData->status);
         break;
     case NFA_FORMAT_CPLT_EVT:
-        ALOGD("%s: NFA_FORMAT_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_FORMAT_CPLT_EVT: status=0x%X", __func__, eventData->status);
         nativeNfcTag_formatStatus (eventData->status == NFA_STATUS_OK);
         break;
 
     case NFA_I93_CMD_CPLT_EVT:
-        ALOGD("%s: NFA_I93_CMD_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_I93_CMD_CPLT_EVT: status=0x%X", __func__, eventData->status);
         break;
 
     case NFA_CE_UICC_LISTEN_CONFIGURED_EVT :
-        ALOGD("%s: NFA_CE_UICC_LISTEN_CONFIGURED_EVT : status=0x%X", __FUNCTION__, eventData->status);
+        ALOGD("%s: NFA_CE_UICC_LISTEN_CONFIGURED_EVT : status=0x%X", __func__, eventData->status);
         break;
 
     case NFA_SET_P2P_LISTEN_TECH_EVT:
-        ALOGD("%s: NFA_SET_P2P_LISTEN_TECH_EVT", __FUNCTION__);
+        ALOGD("%s: NFA_SET_P2P_LISTEN_TECH_EVT", __func__);
         PeerToPeer::getInstance().connectionEventHandler (connEvent, eventData);
         break;
 
     default:
-        ALOGE("%s: unknown event ????", __FUNCTION__);
+        ALOGE("%s: unknown event ????", __func__);
         break;
     }
 }
@@ -544,12 +544,12 @@
 *******************************************************************************/
 static jboolean nfcManager_initNativeStruc (JNIEnv* e, jobject o)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     nfc_jni_native_data* nat = (nfc_jni_native_data*)malloc(sizeof(struct nfc_jni_native_data));
     if (nat == NULL)
     {
-        ALOGE ("%s: fail allocate native data", __FUNCTION__);
+        ALOGE ("%s: fail allocate native data", __func__);
         return JNI_FALSE;
     }
 
@@ -588,17 +588,17 @@
 
     if (nfc_jni_cache_object(e, gNativeNfcTagClassName, &(nat->cached_NfcTag)) == -1)
     {
-        ALOGE ("%s: fail cache NativeNfcTag", __FUNCTION__);
+        ALOGE ("%s: fail cache NativeNfcTag", __func__);
         return JNI_FALSE;
     }
 
     if (nfc_jni_cache_object(e, gNativeP2pDeviceClassName, &(nat->cached_P2pDevice)) == -1)
     {
-        ALOGE ("%s: fail cache NativeP2pDevice", __FUNCTION__);
+        ALOGE ("%s: fail cache NativeP2pDevice", __func__);
         return JNI_FALSE;
     }
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return JNI_TRUE;
 }
 
@@ -614,9 +614,9 @@
 ** Returns:         None
 **
 *******************************************************************************/
-void nfaDeviceManagementCallback (UINT8 dmEvent, tNFA_DM_CBACK_DATA* eventData)
+void nfaDeviceManagementCallback (uint8_t dmEvent, tNFA_DM_CBACK_DATA* eventData)
 {
-    ALOGD ("%s: enter; event=0x%X", __FUNCTION__, dmEvent);
+    ALOGD ("%s: enter; event=0x%X", __func__, dmEvent);
 
     switch (dmEvent)
     {
@@ -624,7 +624,7 @@
         {
             SyncEventGuard guard (sNfaEnableEvent);
             ALOGD ("%s: NFA_DM_ENABLE_EVT; status=0x%X",
-                    __FUNCTION__, eventData->status);
+                    __func__, eventData->status);
             sIsNfaEnabled = eventData->status == NFA_STATUS_OK;
             sIsDisabling = false;
             sNfaEnableEvent.notifyOne ();
@@ -634,7 +634,7 @@
     case NFA_DM_DISABLE_EVT: /* Result of NFA_Disable */
         {
             SyncEventGuard guard (sNfaDisableEvent);
-            ALOGD ("%s: NFA_DM_DISABLE_EVT", __FUNCTION__);
+            ALOGD ("%s: NFA_DM_DISABLE_EVT", __func__);
             sIsNfaEnabled = false;
             sIsDisabling = false;
             sNfaDisableEvent.notifyOne ();
@@ -642,7 +642,7 @@
         break;
 
     case NFA_DM_SET_CONFIG_EVT: //result of NFA_SetConfig
-        ALOGD ("%s: NFA_DM_SET_CONFIG_EVT", __FUNCTION__);
+        ALOGD ("%s: NFA_DM_SET_CONFIG_EVT", __func__);
         {
             SyncEventGuard guard (sNfaSetConfigEvent);
             sNfaSetConfigEvent.notifyOne();
@@ -650,7 +650,7 @@
         break;
 
     case NFA_DM_GET_CONFIG_EVT: /* Result of NFA_GetConfig */
-        ALOGD ("%s: NFA_DM_GET_CONFIG_EVT", __FUNCTION__);
+        ALOGD ("%s: NFA_DM_GET_CONFIG_EVT", __func__);
         {
             SyncEventGuard guard (sNfaGetConfigEvent);
             if (eventData->status == NFA_STATUS_OK &&
@@ -661,7 +661,7 @@
             }
             else
             {
-                ALOGE("%s: NFA_DM_GET_CONFIG failed", __FUNCTION__);
+                ALOGE("%s: NFA_DM_GET_CONFIG failed", __func__);
                 sCurrentConfigLen = 0;
             }
             sNfaGetConfigEvent.notifyOne();
@@ -669,7 +669,7 @@
         break;
 
     case NFA_DM_RF_FIELD_EVT:
-        ALOGD ("%s: NFA_DM_RF_FIELD_EVT; status=0x%X; field status=%u", __FUNCTION__,
+        ALOGD ("%s: NFA_DM_RF_FIELD_EVT; status=0x%X; field status=%u", __func__,
               eventData->rf_field.status, eventData->rf_field.rf_field_status);
         if (!sP2pActive && eventData->rf_field.status == NFA_STATUS_OK)
         {
@@ -692,26 +692,26 @@
     case NFA_DM_NFCC_TIMEOUT_EVT:
         {
             if (dmEvent == NFA_DM_NFCC_TIMEOUT_EVT)
-                ALOGE ("%s: NFA_DM_NFCC_TIMEOUT_EVT; abort", __FUNCTION__);
+                ALOGE ("%s: NFA_DM_NFCC_TIMEOUT_EVT; abort", __func__);
             else if (dmEvent == NFA_DM_NFCC_TRANSPORT_ERR_EVT)
-                ALOGE ("%s: NFA_DM_NFCC_TRANSPORT_ERR_EVT; abort", __FUNCTION__);
+                ALOGE ("%s: NFA_DM_NFCC_TRANSPORT_ERR_EVT; abort", __func__);
 
             nativeNfcTag_abortWaits();
             NfcTag::getInstance().abort ();
             sAbortConnlessWait = true;
             nativeLlcpConnectionlessSocket_abortWait();
             {
-                ALOGD ("%s: aborting  sNfaEnableDisablePollingEvent", __FUNCTION__);
+                ALOGD ("%s: aborting  sNfaEnableDisablePollingEvent", __func__);
                 SyncEventGuard guard (sNfaEnableDisablePollingEvent);
                 sNfaEnableDisablePollingEvent.notifyOne();
             }
             {
-                ALOGD ("%s: aborting  sNfaEnableEvent", __FUNCTION__);
+                ALOGD ("%s: aborting  sNfaEnableEvent", __func__);
                 SyncEventGuard guard (sNfaEnableEvent);
                 sNfaEnableEvent.notifyOne();
             }
             {
-                ALOGD ("%s: aborting  sNfaDisableEvent", __FUNCTION__);
+                ALOGD ("%s: aborting  sNfaDisableEvent", __func__);
                 SyncEventGuard guard (sNfaDisableEvent);
                 sNfaDisableEvent.notifyOne();
             }
@@ -731,7 +731,7 @@
                 sIsDisabling = false;
             }
             PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL);
-            ALOGE ("%s: crash NFC service", __FUNCTION__);
+            ALOGE ("%s: crash NFC service", __func__);
             //////////////////////////////////////////////
             //crash the NFC service process so it can restart automatically
             abort ();
@@ -744,7 +744,7 @@
         break;
 
     default:
-        ALOGD ("%s: unhandled event", __FUNCTION__);
+        ALOGD ("%s: unhandled event", __func__);
         break;
     }
 }
@@ -840,15 +840,15 @@
 *******************************************************************************/
 static jint nfcManager_doRegisterT3tIdentifier(JNIEnv* e, jobject, jbyteArray t3tIdentifier)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     ScopedByteArrayRO bytes(e, t3tIdentifier);
     uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
     size_t bufLen = bytes.size();
     int handle = RoutingManager::getInstance().registerT3tIdentifier(buf, bufLen);
 
-    ALOGD ("%s: handle=%d", __FUNCTION__, handle);
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: handle=%d", __func__, handle);
+    ALOGD ("%s: exit", __func__);
 
     return handle;
 }
@@ -867,11 +867,11 @@
 *******************************************************************************/
 static void nfcManager_doDeregisterT3tIdentifier(JNIEnv*, jobject, jint handle)
 {
-    ALOGD ("%s: enter; handle=%d", __FUNCTION__, handle);
+    ALOGD ("%s: enter; handle=%d", __func__, handle);
 
     RoutingManager::getInstance().deregisterT3tIdentifier(handle);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
 }
 
 /*******************************************************************************
@@ -887,9 +887,9 @@
 *******************************************************************************/
 static jint nfcManager_getLfT3tMax(JNIEnv*, jobject)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     ALOGD ("LF_T3T_MAX=%d", sLfT3tMax);
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
 
     return sLfT3tMax;
 }
@@ -908,14 +908,14 @@
 static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o)
 {
     ALOGD ("%s: enter; ver=%s nfa=%s NCI_VERSION=0x%02X",
-        __FUNCTION__, nfca_version_string, nfa_version_string, NCI_VERSION);
+        __func__, nfca_version_string, nfa_version_string, NCI_VERSION);
     tNFA_STATUS stat = NFA_STATUS_OK;
 
     PowerSwitch & powerSwitch = PowerSwitch::getInstance ();
 
     if (sIsNfaEnabled)
     {
-        ALOGD ("%s: already enabled", __FUNCTION__);
+        ALOGD ("%s: already enabled", __func__);
         goto TheEnd;
     }
 
@@ -970,7 +970,7 @@
                         nat->tech_mask = num;
                     else
                         nat->tech_mask = DEFAULT_TECH_MASK;
-                    ALOGD ("%s: tag polling tech mask=0x%X", __FUNCTION__, nat->tech_mask);
+                    ALOGD ("%s: tag polling tech mask=0x%X", __func__, nat->tech_mask);
                 }
 
                 // if this value exists, set polling interval.
@@ -990,7 +990,7 @@
                     {
                         sNfaGetConfigEvent.wait ();
                         if (sCurrentConfigLen >= 4 || sConfig[1] == NCI_PARAM_ID_LF_T3T_MAX) {
-                            ALOGD("%s: lfT3tMax=%d", __FUNCTION__, sConfig[3]);
+                            ALOGD("%s: lfT3tMax=%d", __func__, sConfig[3]);
                             sLfT3tMax = sConfig[3];
                         }
                     }
@@ -1002,7 +1002,7 @@
             }
         }
 
-        ALOGE ("%s: fail nfa enable; error=0x%X", __FUNCTION__, stat);
+        ALOGE ("%s: fail nfa enable; error=0x%X", __func__, stat);
 
         if (sIsNfaEnabled)
         {
@@ -1016,7 +1016,7 @@
 TheEnd:
     if (sIsNfaEnabled)
         PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER);
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return sIsNfaEnabled ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -1045,11 +1045,11 @@
         tech_mask = (tNFA_TECHNOLOGY_MASK)nat->tech_mask;
     else if (technologies_mask != -1)
         tech_mask = (tNFA_TECHNOLOGY_MASK) technologies_mask;
-    ALOGD ("%s: enter; tech_mask = %02x", __FUNCTION__, tech_mask);
+    ALOGD ("%s: enter; tech_mask = %02x", __func__, tech_mask);
 
     if (sDiscoveryEnabled && !restart)
     {
-        ALOGE ("%s: already discovering", __FUNCTION__);
+        ALOGE ("%s: already discovering", __func__);
         return;
     }
 
@@ -1070,7 +1070,7 @@
         // Start P2P listening if tag polling was enabled
         if (sPollingEnabled)
         {
-            ALOGD ("%s: Enable p2pListening", __FUNCTION__);
+            ALOGD ("%s: Enable p2pListening", __func__);
 
             if (enable_p2p && !sP2pEnabled) {
                 sP2pEnabled = true;
@@ -1120,7 +1120,7 @@
 
     PowerSwitch::getInstance ().setModeOn (PowerSwitch::DISCOVERY);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
 }
 
 
@@ -1138,12 +1138,12 @@
 void nfcManager_disableDiscovery (JNIEnv* e, jobject o)
 {
     tNFA_STATUS status = NFA_STATUS_OK;
-    ALOGD ("%s: enter;", __FUNCTION__);
+    ALOGD ("%s: enter;", __func__);
 
     pn544InteropAbortNow ();
     if (sDiscoveryEnabled == false)
     {
-        ALOGD ("%s: already disabled", __FUNCTION__);
+        ALOGD ("%s: already disabled", __func__);
         goto TheEnd;
     }
 
@@ -1160,7 +1160,7 @@
     if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::DISCOVERY))
         PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER);
 TheEnd:
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
 }
 
 void enableDisableLptd (bool enable)
@@ -1180,24 +1180,24 @@
         stat = NFA_GetConfig(1, configParam);
         if (stat != NFA_STATUS_OK)
         {
-            ALOGE("%s: NFA_GetConfig failed", __FUNCTION__);
+            ALOGE("%s: NFA_GetConfig failed", __func__);
             return;
         }
         sNfaGetConfigEvent.wait ();
         if (sCurrentConfigLen < 4 || sConfig[1] != NCI_PARAM_ID_TAGSNIFF_CFG) {
-            ALOGE("%s: Config TLV length %d returned is too short", __FUNCTION__,
+            ALOGE("%s: Config TLV length %d returned is too short", __func__,
                     sCurrentConfigLen);
             return;
         }
         if (sConfig[3] == 0) {
-            ALOGE("%s: LPTD is disabled, not enabling in current config", __FUNCTION__);
+            ALOGE("%s: LPTD is disabled, not enabling in current config", __func__);
             return;
         }
         sHasLptd = true;
     }
     // Bail if we checked and didn't find any LPTD config before
     if (!sHasLptd) return;
-    UINT8 enable_byte = enable ? 0x01 : 0x00;
+    uint8_t enable_byte = enable ? 0x01 : 0x00;
 
     SyncEventGuard guard(sNfaSetConfigEvent);
 
@@ -1205,7 +1205,7 @@
     if (stat == NFA_STATUS_OK)
         sNfaSetConfigEvent.wait ();
     else
-        ALOGE("%s: Could not configure LPTD feature", __FUNCTION__);
+        ALOGE("%s: Could not configure LPTD feature", __func__);
     return;
 }
 
@@ -1232,13 +1232,13 @@
 
     ScopedUtfChars serviceName(e, sn);
 
-    ALOGD ("%s: enter: sap=%i; name=%s; miu=%i; rw=%i; buffLen=%i", __FUNCTION__, nSap, serviceName.c_str(), miu, rw, linearBufferLength);
+    ALOGD ("%s: enter: sap=%i; name=%s; miu=%i; rw=%i; buffLen=%i", __func__, nSap, serviceName.c_str(), miu, rw, linearBufferLength);
 
     /* Create new NativeLlcpServiceSocket object */
     jobject serviceSocket = NULL;
     if (nfc_jni_cache_object_local(e, gNativeLlcpServiceSocketClassName, &(serviceSocket)) == -1)
     {
-        ALOGE ("%s: Llcp socket object creation error", __FUNCTION__);
+        ALOGE ("%s: Llcp socket object creation error", __func__);
         return NULL;
     }
 
@@ -1247,13 +1247,13 @@
     if (e->ExceptionCheck())
     {
         e->ExceptionClear();
-        ALOGE("%s: Llcp Socket get object class error", __FUNCTION__);
+        ALOGE("%s: Llcp Socket get object class error", __func__);
         return NULL;
     }
 
     if (!PeerToPeer::getInstance().registerServer (jniHandle, serviceName.c_str()))
     {
-        ALOGE("%s: RegisterServer error", __FUNCTION__);
+        ALOGE("%s: RegisterServer error", __func__);
         return NULL;
     }
 
@@ -1262,25 +1262,25 @@
     /* Set socket handle to be the same as the NfaHandle*/
     f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mHandle", "I");
     e->SetIntField(serviceSocket, f, (jint) jniHandle);
-    ALOGD ("%s: socket Handle = 0x%X", __FUNCTION__, jniHandle);
+    ALOGD ("%s: socket Handle = 0x%X", __func__, jniHandle);
 
     /* Set socket linear buffer length */
     f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalLinearBufferLength", "I");
     e->SetIntField(serviceSocket, f,(jint)linearBufferLength);
-    ALOGD ("%s: buffer length = %d", __FUNCTION__, linearBufferLength);
+    ALOGD ("%s: buffer length = %d", __func__, linearBufferLength);
 
     /* Set socket MIU */
     f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalMiu", "I");
     e->SetIntField(serviceSocket, f,(jint)miu);
-    ALOGD ("%s: MIU = %d", __FUNCTION__, miu);
+    ALOGD ("%s: MIU = %d", __func__, miu);
 
     /* Set socket RW */
     f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalRw", "I");
     e->SetIntField(serviceSocket, f,(jint)rw);
-    ALOGD ("%s:  RW = %d", __FUNCTION__, rw);
+    ALOGD ("%s:  RW = %d", __func__, rw);
 
     sLastError = 0;
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return serviceSocket;
 }
 
@@ -1298,7 +1298,7 @@
 *******************************************************************************/
 static jint nfcManager_doGetLastError(JNIEnv*, jobject)
 {
-    ALOGD ("%s: last error=%i", __FUNCTION__, sLastError);
+    ALOGD ("%s: last error=%i", __func__, sLastError);
     return sLastError;
 }
 
@@ -1316,7 +1316,7 @@
 *******************************************************************************/
 static jboolean nfcManager_doDeinitialize (JNIEnv*, jobject)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     sIsDisabling = true;
 
@@ -1331,13 +1331,13 @@
         tNFA_STATUS stat = NFA_Disable (TRUE /* graceful */);
         if (stat == NFA_STATUS_OK)
         {
-            ALOGD ("%s: wait for completion", __FUNCTION__);
+            ALOGD ("%s: wait for completion", __func__);
             sNfaDisableEvent.wait (); //wait for NFA command to finish
             PeerToPeer::getInstance ().handleNfcOnOff (false);
         }
         else
         {
-            ALOGE ("%s: fail disable; error=0x%X", __FUNCTION__, stat);
+            ALOGE ("%s: fail disable; error=0x%X", __func__, stat);
         }
     }
     nativeNfcTag_abortWaits();
@@ -1361,7 +1361,7 @@
     NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
     theInstance.Finalize();
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return JNI_TRUE;
 }
 
@@ -1383,7 +1383,7 @@
 *******************************************************************************/
 static jobject nfcManager_doCreateLlcpSocket (JNIEnv* e, jobject, jint nSap, jint miu, jint rw, jint linearBufferLength)
 {
-    ALOGD ("%s: enter; sap=%d; miu=%d; rw=%d; buffer len=%d", __FUNCTION__, nSap, miu, rw, linearBufferLength);
+    ALOGD ("%s: enter; sap=%d; miu=%d; rw=%d; buffer len=%d", __func__, nSap, miu, rw, linearBufferLength);
 
     PeerToPeer::tJNI_HANDLE jniHandle = PeerToPeer::getInstance().getNewJniHandle ();
     PeerToPeer::getInstance().createClient (jniHandle, miu, rw);
@@ -1392,7 +1392,7 @@
     jobject clientSocket = NULL;
     if (nfc_jni_cache_object_local(e, gNativeLlcpSocketClassName, &(clientSocket)) == -1)
     {
-        ALOGE ("%s: fail Llcp socket creation", __FUNCTION__);
+        ALOGE ("%s: fail Llcp socket creation", __func__);
         return clientSocket;
     }
 
@@ -1401,7 +1401,7 @@
     if (e->ExceptionCheck())
     {
         e->ExceptionClear();
-        ALOGE ("%s: fail get class object", __FUNCTION__);
+        ALOGE ("%s: fail get class object", __func__);
         return clientSocket;
     }
 
@@ -1423,7 +1423,7 @@
     f = e->GetFieldID (clsNativeLlcpSocket.get(), "mLocalRw", "I");
     e->SetIntField (clientSocket, f, (jint) rw);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return clientSocket;
 }
 
@@ -1443,7 +1443,7 @@
 *******************************************************************************/
 static jobject nfcManager_doCreateLlcpConnectionlessSocket (JNIEnv *, jobject, jint nSap, jstring /*sn*/)
 {
-    ALOGD ("%s: nSap=0x%X", __FUNCTION__, nSap);
+    ALOGD ("%s: nSap=0x%X", __func__, nSap);
     return NULL;
 }
 
@@ -1494,7 +1494,7 @@
 *******************************************************************************/
 static jboolean nfcManager_doCheckLlcp(JNIEnv*, jobject)
 {
-    ALOGD("%s", __FUNCTION__);
+    ALOGD("%s", __func__);
     return JNI_TRUE;
 }
 
@@ -1510,7 +1510,7 @@
 *******************************************************************************/
 static jboolean nfcManager_doActivateLlcp(JNIEnv*, jobject)
 {
-    ALOGD("%s", __FUNCTION__);
+    ALOGD("%s", __func__);
     return JNI_TRUE;
 }
 
@@ -1543,13 +1543,13 @@
 *******************************************************************************/
 static jboolean nfcManager_doDownload(JNIEnv*, jobject)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
 
     theInstance.Initialize(); //start GKI, NCI task, NFC task
     theInstance.DownloadFirmware ();
     theInstance.Finalize();
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return JNI_TRUE;
 }
 
@@ -1565,7 +1565,7 @@
 *******************************************************************************/
 static void nfcManager_doResetTimeouts(JNIEnv*, jobject)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     NfcTag::getInstance().resetAllTransceiveTimeouts ();
 }
 
@@ -1587,10 +1587,10 @@
 {
     if (timeout <= 0)
     {
-        ALOGE("%s: Timeout must be positive.",__FUNCTION__);
+        ALOGE("%s: Timeout must be positive.",__func__);
         return false;
     }
-    ALOGD ("%s: tech=%d, timeout=%d", __FUNCTION__, tech, timeout);
+    ALOGD ("%s: tech=%d, timeout=%d", __func__, tech, timeout);
     NfcTag::getInstance().setTransceiveTimeout (tech, timeout);
     return true;
 }
@@ -1611,7 +1611,7 @@
 static jint nfcManager_doGetTimeout(JNIEnv*, jobject, jint tech)
 {
     int timeout = NfcTag::getInstance().getTransceiveTimeout (tech);
-    ALOGD ("%s: tech=%d, timeout=%d", __FUNCTION__, tech, timeout);
+    ALOGD ("%s: tech=%d, timeout=%d", __func__, tech, timeout);
     return timeout;
 }
 
@@ -1651,7 +1651,7 @@
 *******************************************************************************/
 static void nfcManager_doSetP2pInitiatorModes (JNIEnv *e, jobject o, jint modes)
 {
-    ALOGD ("%s: modes=0x%X", __FUNCTION__, modes);
+    ALOGD ("%s: modes=0x%X", __func__, modes);
     struct nfc_jni_native_data *nat = getNative(e, o);
 
     tNFA_TECHNOLOGY_MASK mask = 0;
@@ -1679,7 +1679,7 @@
 *******************************************************************************/
 static void nfcManager_doSetP2pTargetModes (JNIEnv*, jobject, jint modes)
 {
-    ALOGD ("%s: modes=0x%X", __FUNCTION__, modes);
+    ALOGD ("%s: modes=0x%X", __func__, modes);
     // Map in the right modes
     tNFA_TECHNOLOGY_MASK mask = 0;
     if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A;
@@ -1805,9 +1805,9 @@
 *******************************************************************************/
 int register_com_android_nfc_NativeNfcManager (JNIEnv *e)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL);
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return jniRegisterNativeMethods (e, gNativeNfcManagerClassName, gMethods, NELEM (gMethods));
 }
 
@@ -1826,7 +1826,7 @@
 {
     tNFA_STATUS status = NFA_STATUS_FAILED;
 
-    ALOGD ("%s: is start=%d", __FUNCTION__, isStart);
+    ALOGD ("%s: is start=%d", __func__, isStart);
     SyncEventGuard guard (sNfaEnableDisablePollingEvent);
     status  = isStart ? NFA_StartRfDiscovery () : NFA_StopRfDiscovery ();
     if (status == NFA_STATUS_OK)
@@ -1836,7 +1836,7 @@
     }
     else
     {
-        ALOGE ("%s: Failed to start/stop RF discovery; error=0x%X", __FUNCTION__, status);
+        ALOGE ("%s: Failed to start/stop RF discovery; error=0x%X", __func__, status);
     }
 }
 
@@ -1874,7 +1874,7 @@
     // If polling for Active mode, set the ordering so that we choose Active over Passive mode first.
     if (nat && (nat->tech_mask & (NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE)))
     {
-        UINT8  act_mode_order_param[] = { 0x01 };
+        uint8_t  act_mode_order_param[] = { 0x01 };
         SyncEventGuard guard (sNfaSetConfigEvent);
         stat = NFA_SetConfig(NCI_PARAM_ID_ACT_ORDER, sizeof(act_mode_order_param), &act_mode_order_param[0]);
         if (stat == NFA_STATUS_OK)
@@ -1884,11 +1884,11 @@
     //configure RF polling frequency for each technology
     static tNFA_DM_DISC_FREQ_CFG nfa_dm_disc_freq_cfg;
     //values in the polling_frequency[] map to members of nfa_dm_disc_freq_cfg
-    UINT8 polling_frequency [8] = {1, 1, 1, 1, 1, 1, 1, 1};
+    uint8_t polling_frequency [8] = {1, 1, 1, 1, 1, 1, 1, 1};
     actualLen = GetStrValue(NAME_POLL_FREQUENCY, (char*)polling_frequency, 8);
     if (actualLen == 8)
     {
-        ALOGD ("%s: polling frequency", __FUNCTION__);
+        ALOGD ("%s: polling frequency", __func__);
         memset (&nfa_dm_disc_freq_cfg, 0, sizeof(nfa_dm_disc_freq_cfg));
         nfa_dm_disc_freq_cfg.pa = polling_frequency [0];
         nfa_dm_disc_freq_cfg.pb = polling_frequency [1];
@@ -1929,14 +1929,14 @@
 *******************************************************************************/
 void startStopPolling (bool isStartPolling)
 {
-    ALOGD ("%s: enter; isStart=%u", __FUNCTION__, isStartPolling);
+    ALOGD ("%s: enter; isStart=%u", __func__, isStartPolling);
     startRfDiscovery (false);
 
     if (isStartPolling) startPolling_rfDiscoveryDisabled(0);
     else stopPolling_rfDiscoveryDisabled();
 
     startRfDiscovery (true);
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
 }
 
 
@@ -1950,17 +1950,17 @@
     else if (tech_mask == 0) tech_mask = DEFAULT_TECH_MASK;
 
     SyncEventGuard guard (sNfaEnableDisablePollingEvent);
-    ALOGD ("%s: enable polling", __FUNCTION__);
+    ALOGD ("%s: enable polling", __func__);
     stat = NFA_EnablePolling (tech_mask);
     if (stat == NFA_STATUS_OK)
     {
-        ALOGD ("%s: wait for enable event", __FUNCTION__);
+        ALOGD ("%s: wait for enable event", __func__);
         sPollingEnabled = true;
         sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT
     }
     else
     {
-        ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, stat);
+        ALOGE ("%s: fail enable polling; error=0x%X", __func__, stat);
     }
 
     return stat;
@@ -1970,13 +1970,13 @@
     tNFA_STATUS stat = NFA_STATUS_FAILED;
 
     SyncEventGuard guard (sNfaEnableDisablePollingEvent);
-    ALOGD ("%s: disable polling", __FUNCTION__);
+    ALOGD ("%s: disable polling", __func__);
     stat = NFA_DisablePolling ();
     if (stat == NFA_STATUS_OK) {
         sPollingEnabled = false;
         sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT
     } else {
-        ALOGE ("%s: fail disable polling; error=0x%X", __FUNCTION__, stat);
+        ALOGE ("%s: fail disable polling; error=0x%X", __func__, stat);
     }
 
     return stat;
diff --git a/nci/jni/NativeNfcTag.cpp b/nci/jni/NativeNfcTag.cpp
index d5edcd9..6c0e585 100644
--- a/nci/jni/NativeNfcTag.cpp
+++ b/nci/jni/NativeNfcTag.cpp
@@ -87,7 +87,7 @@
 static bool         sCheckNdefCapable = false; //whether tag has NDEF capability
 static tNFA_HANDLE  sNdefTypeHandlerHandle = NFA_HANDLE_INVALID;
 static tNFA_INTF_TYPE   sCurrentRfInterface = NFA_INTERFACE_ISO_DEP;
-static std::basic_string<UINT8> sRxDataBuffer;
+static std::basic_string<uint8_t> sRxDataBuffer;
 static tNFA_STATUS  sRxDataStatus = NFA_STATUS_OK;
 static bool         sWaitingForTransceive = false;
 static bool         sTransceiveRfTimeout = false;
@@ -133,7 +133,7 @@
 *******************************************************************************/
 void nativeNfcTag_abortWaits ()
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     {
         SyncEventGuard g (sReadEvent);
         sReadEvent.notifyOne ();
@@ -173,7 +173,7 @@
 *******************************************************************************/
 void nativeNfcTag_doReadCompleted (tNFA_STATUS status)
 {
-    ALOGD ("%s: status=0x%X; is reading=%u", __FUNCTION__, status, sIsReadingNdefMessage);
+    ALOGD ("%s: status=0x%X; is reading=%u", __func__, status, sIsReadingNdefMessage);
 
     if (sIsReadingNdefMessage == false)
         return; //not reading NDEF message right now, so just return
@@ -218,21 +218,21 @@
 *******************************************************************************/
 static void ndefHandlerCallback (tNFA_NDEF_EVT event, tNFA_NDEF_EVT_DATA *eventData)
 {
-    ALOGD ("%s: event=%u, eventData=%p", __FUNCTION__, event, eventData);
+    ALOGD ("%s: event=%u, eventData=%p", __func__, event, eventData);
 
     switch (event)
     {
     case NFA_NDEF_REGISTER_EVT:
         {
             tNFA_NDEF_REGISTER& ndef_reg = eventData->ndef_reg;
-            ALOGD ("%s: NFA_NDEF_REGISTER_EVT; status=0x%X; h=0x%X", __FUNCTION__, ndef_reg.status, ndef_reg.ndef_type_handle);
+            ALOGD ("%s: NFA_NDEF_REGISTER_EVT; status=0x%X; h=0x%X", __func__, ndef_reg.status, ndef_reg.ndef_type_handle);
             sNdefTypeHandlerHandle = ndef_reg.ndef_type_handle;
         }
         break;
 
     case NFA_NDEF_DATA_EVT:
         {
-            ALOGD ("%s: NFA_NDEF_DATA_EVT; data_len = %lu", __FUNCTION__, eventData->ndef_data.len);
+            ALOGD ("%s: NFA_NDEF_DATA_EVT; data_len = %u", __func__, eventData->ndef_data.len);
             sReadDataLen = eventData->ndef_data.len;
             sReadData = (uint8_t*) malloc (sReadDataLen);
             memcpy (sReadData, eventData->ndef_data.p_data, eventData->ndef_data.len);
@@ -240,7 +240,7 @@
         break;
 
     default:
-        ALOGE ("%s: Unknown event %u ????", __FUNCTION__, event);
+        ALOGE ("%s: Unknown event %u ????", __func__, event);
         break;
     }
 }
@@ -259,7 +259,7 @@
 *******************************************************************************/
 static jbyteArray nativeNfcTag_doRead (JNIEnv* e, jobject)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     tNFA_STATUS status = NFA_STATUS_FAILED;
     jbyteArray buf = NULL;
 
@@ -289,14 +289,14 @@
 
         if (sReadDataLen > 0) //if stack actually read data from the tag
         {
-            ALOGD ("%s: read %u bytes", __FUNCTION__, sReadDataLen);
+            ALOGD ("%s: read %u bytes", __func__, sReadDataLen);
             buf = e->NewByteArray (sReadDataLen);
             e->SetByteArrayRegion (buf, 0, sReadDataLen, (jbyte*) sReadData);
         }
     }
     else
     {
-        ALOGD ("%s: create empty buffer", __FUNCTION__);
+        ALOGD ("%s: create empty buffer", __func__);
         sReadDataLen = 0;
         sReadData = (uint8_t*) malloc (1);
         buf = e->NewByteArray (sReadDataLen);
@@ -310,7 +310,7 @@
     }
     sReadDataLen = 0;
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return buf;
 }
 
@@ -372,18 +372,18 @@
     jboolean result = JNI_FALSE;
     tNFA_STATUS status = 0;
     const int maxBufferSize = 1024;
-    UINT8 buffer[maxBufferSize] = { 0 };
-    UINT32 curDataSize = 0;
+    uint8_t buffer[maxBufferSize] = { 0 };
+    uint32_t curDataSize = 0;
 
     ScopedByteArrayRO bytes(e, buf);
-    UINT8* p_data = const_cast<UINT8*>(reinterpret_cast<const UINT8*>(&bytes[0])); // TODO: const-ness API bug in NFA_RwWriteNDef!
+    uint8_t* p_data = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); // TODO: const-ness API bug in NFA_RwWriteNDef!
 
-    ALOGD ("%s: enter; len = %zu", __FUNCTION__, bytes.size());
+    ALOGD ("%s: enter; len = %zu", __func__, bytes.size());
 
     /* Create the write semaphore */
     if (sem_init (&sWriteSem, 0, 0) == -1)
     {
-        ALOGE ("%s: semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: semaphore creation failed (errno=0x%08x)", __func__, errno);
         return JNI_FALSE;
     }
 
@@ -394,7 +394,7 @@
         //and tag is capable of storing NDEF message
         if (sCheckNdefCapable)
         {
-            ALOGD ("%s: try format", __FUNCTION__);
+            ALOGD ("%s: try format", __func__);
             sem_init (&sFormatSem, 0, 0);
             sFormatOk = false;
             if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
@@ -405,7 +405,7 @@
                 status = EXTNS_MfcFormatTag (mfc_key1, sizeof(mfc_key1));
                 if (status != NFA_STATUS_OK)
                 {
-                    ALOGE ("%s: can't format mifare classic tag", __FUNCTION__);
+                    ALOGE ("%s: can't format mifare classic tag", __func__);
                     sem_destroy (&sFormatSem);
                     goto TheEnd;
                 }
@@ -418,7 +418,7 @@
                     status = EXTNS_MfcFormatTag (mfc_key2, sizeof(mfc_key2));
                     if (status != NFA_STATUS_OK)
                     {
-                        ALOGE ("%s: can't format mifare classic tag", __FUNCTION__);
+                        ALOGE ("%s: can't format mifare classic tag", __func__);
                         sem_destroy (&sFormatSem);
                         goto TheEnd;
                     }
@@ -433,7 +433,7 @@
             if (sFormatOk == false) //if format operation failed
                 goto TheEnd;
         }
-        ALOGD ("%s: try write", __FUNCTION__);
+        ALOGD ("%s: try write", __func__);
         status = NFA_RwWriteNDef (p_data, bytes.size());
     }
     else if (bytes.size() == 0)
@@ -441,7 +441,7 @@
         //if (NXP TagWriter wants to erase tag) then create and write an empty ndef message
         NDEF_MsgInit (buffer, maxBufferSize, &curDataSize);
         status = NDEF_MsgAddRec (buffer, maxBufferSize, &curDataSize, NDEF_TNF_EMPTY, NULL, 0, NULL, 0, NULL, 0);
-        ALOGD ("%s: create empty ndef msg; status=%u; size=%lu", __FUNCTION__, status, curDataSize);
+        ALOGD ("%s: create empty ndef msg; status=%u; size=%u", __func__, status, curDataSize);
         if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
         {
             status = EXTNS_MfcWriteNDef (buffer, curDataSize);
@@ -453,7 +453,7 @@
     }
     else
     {
-        ALOGD ("%s: NFA_RwWriteNDef", __FUNCTION__);
+        ALOGD ("%s: NFA_RwWriteNDef", __func__);
         if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
         {
             status = EXTNS_MfcWriteNDef (p_data, bytes.size());
@@ -466,7 +466,7 @@
 
     if (status != NFA_STATUS_OK)
     {
-        ALOGE ("%s: write/format error=%d", __FUNCTION__, status);
+        ALOGE ("%s: write/format error=%d", __func__, status);
         goto TheEnd;
     }
 
@@ -474,7 +474,7 @@
     sWriteOk = false;
     if (sem_wait (&sWriteSem))
     {
-        ALOGE ("%s: wait semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: wait semaphore (errno=0x%08x)", __func__, errno);
         goto TheEnd;
     }
 
@@ -484,10 +484,10 @@
     /* Destroy semaphore */
     if (sem_destroy (&sWriteSem))
     {
-        ALOGE ("%s: failed destroy semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: failed destroy semaphore (errno=0x%08x)", __func__, errno);
     }
     sWriteWaitingForComplete = JNI_FALSE;
-    ALOGD ("%s: exit; result=%d", __FUNCTION__, result);
+    ALOGD ("%s: exit; result=%d", __func__, result);
     return result;
 }
 
@@ -560,21 +560,21 @@
 *******************************************************************************/
 static jint nativeNfcTag_doConnect (JNIEnv*, jobject, jint targetHandle)
 {
-    ALOGD ("%s: targetHandle = %d", __FUNCTION__, targetHandle);
+    ALOGD ("%s: targetHandle = %d", __func__, targetHandle);
     int i = targetHandle;
     NfcTag& natTag = NfcTag::getInstance ();
     int retCode = NFCSTATUS_SUCCESS;
 
     if (i >= NfcTag::MAX_NUM_TECHNOLOGY)
     {
-        ALOGE ("%s: Handle not found", __FUNCTION__);
+        ALOGE ("%s: Handle not found", __func__);
         retCode = NFCSTATUS_FAILED;
         goto TheEnd;
     }
 
     if (natTag.getActivationState() != NfcTag::Active)
     {
-        ALOGE ("%s: tag already deactivated", __FUNCTION__);
+        ALOGE ("%s: tag already deactivated", __func__);
         retCode = NFCSTATUS_FAILED;
         goto TheEnd;
     }
@@ -584,14 +584,14 @@
 
     if (sCurrentConnectedTargetProtocol != NFC_PROTOCOL_ISO_DEP)
     {
-        ALOGD ("%s() Nfc type = %d, do nothing for non ISO_DEP", __FUNCTION__, sCurrentConnectedTargetProtocol);
+        ALOGD ("%s() Nfc type = %d, do nothing for non ISO_DEP", __func__, sCurrentConnectedTargetProtocol);
         retCode = NFCSTATUS_SUCCESS;
         goto TheEnd;
     }
 
     if (sCurrentConnectedTargetType == TARGET_TYPE_ISO14443_3A || sCurrentConnectedTargetType == TARGET_TYPE_ISO14443_3B)
     {
-        ALOGD ("%s: switching to tech: %d need to switch rf intf to frame", __FUNCTION__, sCurrentConnectedTargetType);
+        ALOGD ("%s: switching to tech: %d need to switch rf intf to frame", __func__, sCurrentConnectedTargetType);
         retCode = switchRfInterface(NFA_INTERFACE_FRAME) ? NFA_STATUS_OK : NFA_STATUS_FAILED;
     }
     else
@@ -600,7 +600,7 @@
     }
 
 TheEnd:
-    ALOGD ("%s: exit 0x%X", __FUNCTION__, retCode);
+    ALOGD ("%s: exit 0x%X", __func__, retCode);
     return retCode;
 }
 
@@ -618,7 +618,7 @@
 *******************************************************************************/
 static int reSelect (tNFA_INTF_TYPE rfInterface, bool fSwitchIfNeeded)
 {
-    ALOGD ("%s: enter; rf intf = %d, current intf = %d", __FUNCTION__, rfInterface, sCurrentRfInterface);
+    ALOGD ("%s: enter; rf intf = %d, current intf = %d", __func__, rfInterface, sCurrentRfInterface);
 
     sRfInterfaceMutex.lock ();
 
@@ -639,7 +639,7 @@
         //if tag has shutdown, abort this method
         if (NfcTag::getInstance ().isNdefDetectionTimedOut())
         {
-            ALOGD ("%s: ndef detection timeout; break", __FUNCTION__);
+            ALOGD ("%s: ndef detection timeout; break", __func__);
             rVal = STATUS_CODE_TARGET_LOST;
             break;
         }
@@ -648,16 +648,16 @@
             SyncEventGuard g (sReconnectEvent);
             gIsTagDeactivating = true;
             sGotDeactivate = false;
-            ALOGD ("%s: deactivate to sleep", __FUNCTION__);
+            ALOGD ("%s: deactivate to sleep", __func__);
             if (NFA_STATUS_OK != (status = NFA_Deactivate (TRUE))) //deactivate to sleep state
             {
-                ALOGE ("%s: deactivate failed, status = %d", __FUNCTION__, status);
+                ALOGE ("%s: deactivate failed, status = %d", __func__, status);
                 break;
             }
 
             if (sReconnectEvent.wait (1000) == false) //if timeout occurred
             {
-                ALOGE ("%s: timeout waiting for deactivate", __FUNCTION__);
+                ALOGE ("%s: timeout waiting for deactivate", __func__);
             }
         }
 
@@ -669,7 +669,7 @@
 
         if (NfcTag::getInstance ().getActivationState () != NfcTag::Sleep)
         {
-            ALOGE ("%s: tag is not in sleep", __FUNCTION__);
+            ALOGE ("%s: tag is not in sleep", __func__);
             rVal = STATUS_CODE_TARGET_LOST;
             break;
         }
@@ -680,26 +680,26 @@
             SyncEventGuard g2 (sReconnectEvent);
 
             sConnectWaitingForComplete = JNI_TRUE;
-            ALOGD ("%s: select interface %u", __FUNCTION__, rfInterface);
+            ALOGD ("%s: select interface %u", __func__, rfInterface);
             gIsSelectingRfInterface = true;
             if (NFA_STATUS_OK != (status = NFA_Select (natTag.mTechHandles[0], natTag.mTechLibNfcTypes[0], rfInterface)))
             {
-                ALOGE ("%s: NFA_Select failed, status = %d", __FUNCTION__, status);
+                ALOGE ("%s: NFA_Select failed, status = %d", __func__, status);
                 break;
             }
 
             sConnectOk = false;
             if (sReconnectEvent.wait (1000) == false) //if timeout occured
             {
-                ALOGE ("%s: timeout waiting for select", __FUNCTION__);
+                ALOGE ("%s: timeout waiting for select", __func__);
                 break;
             }
         }
 
-        ALOGD("%s: select completed; sConnectOk=%d", __FUNCTION__, sConnectOk);
+        ALOGD("%s: select completed; sConnectOk=%d", __func__, sConnectOk);
         if (NfcTag::getInstance ().getActivationState () != NfcTag::Active)
         {
-            ALOGE("%s: tag is not active", __FUNCTION__);
+            ALOGE("%s: tag is not active", __func__);
             rVal = STATUS_CODE_TARGET_LOST;
             break;
         }
@@ -718,7 +718,7 @@
     gIsTagDeactivating = false;
     gIsSelectingRfInterface = false;
     sRfInterfaceMutex.unlock ();
-    ALOGD ("%s: exit; status=%d", __FUNCTION__, rVal);
+    ALOGD ("%s: exit; status=%d", __func__, rVal);
     return rVal;
 }
 
@@ -738,11 +738,11 @@
 
     if (sCurrentConnectedTargetProtocol != NFC_PROTOCOL_ISO_DEP)
     {
-        ALOGD ("%s: protocol: %d not ISO_DEP, do nothing", __FUNCTION__, natTag.mTechLibNfcTypes[0]);
+        ALOGD ("%s: protocol: %d not ISO_DEP, do nothing", __func__, natTag.mTechLibNfcTypes[0]);
         return true;
     }
 
-    ALOGD ("%s: new rf intf = %d, cur rf intf = %d", __FUNCTION__, rfInterface, sCurrentRfInterface);
+    ALOGD ("%s: new rf intf = %d, cur rf intf = %d", __func__, rfInterface, sCurrentRfInterface);
 
     return (0 == reSelect(rfInterface, true));
 }
@@ -761,13 +761,13 @@
 *******************************************************************************/
 static jint nativeNfcTag_doReconnect (JNIEnv*, jobject)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     int retCode = NFCSTATUS_SUCCESS;
     NfcTag& natTag = NfcTag::getInstance ();
 
     if (natTag.getActivationState() != NfcTag::Active)
     {
-        ALOGE ("%s: tag already deactivated", __FUNCTION__);
+        ALOGE ("%s: tag already deactivated", __func__);
         retCode = NFCSTATUS_FAILED;
         goto TheEnd;
     }
@@ -775,7 +775,7 @@
     // special case for Kovio
     if (sCurrentConnectedTargetProtocol == TARGET_TYPE_KOVIO_BARCODE)
     {
-        ALOGD ("%s: fake out reconnect for Kovio", __FUNCTION__);
+        ALOGD ("%s: fake out reconnect for Kovio", __func__);
         goto TheEnd;
     }
 
@@ -788,7 +788,7 @@
         retCode = reSelect (NFA_INTERFACE_MIFARE, false);
 
 TheEnd:
-    ALOGD ("%s: exit 0x%X", __FUNCTION__, retCode);
+    ALOGD ("%s: exit 0x%X", __func__, retCode);
     return retCode;
 }
 
@@ -807,7 +807,7 @@
 *******************************************************************************/
 static jint nativeNfcTag_doHandleReconnect (JNIEnv *e, jobject o, jint targetHandle)
 {
-    ALOGD ("%s: targetHandle = %d", __FUNCTION__, targetHandle);
+    ALOGD ("%s: targetHandle = %d", __func__, targetHandle);
     return nativeNfcTag_doConnect (e, o, targetHandle);
 }
 
@@ -825,23 +825,23 @@
 *******************************************************************************/
 static jboolean nativeNfcTag_doDisconnect (JNIEnv*, jobject)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     tNFA_STATUS nfaStat = NFA_STATUS_OK;
 
     NfcTag::getInstance().resetAllTransceiveTimeouts ();
 
     if (NfcTag::getInstance ().getActivationState () != NfcTag::Active)
     {
-        ALOGE ("%s: tag already deactivated", __FUNCTION__);
+        ALOGE ("%s: tag already deactivated", __func__);
         goto TheEnd;
     }
 
     nfaStat = NFA_Deactivate (FALSE);
     if (nfaStat != NFA_STATUS_OK)
-        ALOGE ("%s: deactivate failed; error=0x%X", __FUNCTION__, nfaStat);
+        ALOGE ("%s: deactivate failed; error=0x%X", __func__, nfaStat);
 
 TheEnd:
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return (nfaStat == NFA_STATUS_OK) ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -861,7 +861,7 @@
 void nativeNfcTag_doTransceiveStatus (tNFA_STATUS status, uint8_t* buf, uint32_t bufLen)
 {
     SyncEventGuard g (sTransceiveEvent);
-    ALOGD ("%s: data len=%d", __FUNCTION__, bufLen);
+    ALOGD ("%s: data len=%d", __func__, bufLen);
 
     if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
     {
@@ -874,7 +874,7 @@
 
     if (!sWaitingForTransceive)
     {
-        ALOGE ("%s: drop data", __FUNCTION__);
+        ALOGE ("%s: drop data", __func__);
         return;
     }
     sRxDataStatus = status;
@@ -889,7 +889,7 @@
 void nativeNfcTag_notifyRfTimeout ()
 {
     SyncEventGuard g (sTransceiveEvent);
-    ALOGD ("%s: waiting for transceive: %d", __FUNCTION__, sWaitingForTransceive);
+    ALOGD ("%s: waiting for transceive: %d", __func__, sWaitingForTransceive);
     if (!sWaitingForTransceive)
         return;
 
@@ -915,7 +915,7 @@
 static jbyteArray nativeNfcTag_doTransceive (JNIEnv* e, jobject o, jbyteArray data, jboolean raw, jintArray statusTargetLost)
 {
     int timeout = NfcTag::getInstance ().getTransceiveTimeout (sCurrentConnectedTargetType);
-    ALOGD ("%s: enter; raw=%u; timeout = %d", __FUNCTION__, raw, timeout);
+    ALOGD ("%s: enter; raw=%u; timeout = %d", __func__, raw, timeout);
 
     bool waitOk = false;
     bool isNack = false;
@@ -931,7 +931,7 @@
                 *targetLost = 1; //causes NFC service to throw TagLostException
             e->ReleaseIntArrayElements (statusTargetLost, targetLost, 0);
         }
-        ALOGD ("%s: tag not active", __FUNCTION__);
+        ALOGD ("%s: tag not active", __func__);
         return NULL;
     }
 
@@ -972,7 +972,7 @@
 
             if (status != NFA_STATUS_OK)
             {
-                ALOGE ("%s: fail send; error=%d", __FUNCTION__, status);
+                ALOGE ("%s: fail send; error=%d", __func__, status);
                 break;
             }
             waitOk = sTransceiveEvent.wait (timeout);
@@ -980,7 +980,7 @@
 
         if (waitOk == false || sTransceiveRfTimeout) //if timeout occurred
         {
-            ALOGE ("%s: wait response timeout", __FUNCTION__);
+            ALOGE ("%s: wait response timeout", __func__);
             if (targetLost)
                 *targetLost = 1; //causes NFC service to throw TagLostException
             break;
@@ -988,13 +988,13 @@
 
         if (NfcTag::getInstance ().getActivationState () != NfcTag::Active)
         {
-            ALOGE ("%s: already deactivated", __FUNCTION__);
+            ALOGE ("%s: already deactivated", __func__);
             if (targetLost)
                 *targetLost = 1; //causes NFC service to throw TagLostException
             break;
         }
 
-        ALOGD ("%s: response %zu bytes", __FUNCTION__, sRxDataBuffer.size());
+        ALOGD ("%s: response %zu bytes", __func__, sRxDataBuffer.size());
 
         if ((natTag.getProtocol () == NFA_PROTOCOL_T2T) &&
             natTag.isT2tNackResponse (sRxDataBuffer.data(), sRxDataBuffer.size()))
@@ -1009,9 +1009,9 @@
                 //Some Mifare Ultralight C tags enter the HALT state after it
                 //responds with a NACK.  Need to perform a "reconnect" operation
                 //to wake it.
-                ALOGD ("%s: try reconnect", __FUNCTION__);
+                ALOGD ("%s: try reconnect", __func__);
                 nativeNfcTag_doReconnect (NULL, NULL);
-                ALOGD ("%s: reconnect finish", __FUNCTION__);
+                ALOGD ("%s: reconnect finish", __func__);
             }
             else if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
             {
@@ -1032,7 +1032,7 @@
                         e->SetByteArrayRegion (result.get (), 0, transDataLen, (const jbyte *) transData);
                     }
                     else
-                        ALOGE ("%s: Failed to allocate java byte array", __FUNCTION__);
+                        ALOGE ("%s: Failed to allocate java byte array", __func__);
                 }
             }
             else
@@ -1044,7 +1044,7 @@
                     e->SetByteArrayRegion(result.get(), 0, sRxDataBuffer.size(), (const jbyte *) sRxDataBuffer.data());
                 }
                 else
-                    ALOGE ("%s: Failed to allocate java byte array", __FUNCTION__);
+                    ALOGE ("%s: Failed to allocate java byte array", __func__);
             } // else a nack is treated as a transceive failure to the upper layers
 
             sRxDataBuffer.clear();
@@ -1055,7 +1055,7 @@
     if (targetLost)
         e->ReleaseIntArrayElements (statusTargetLost, targetLost, 0);
 
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return result.release();
 }
 
@@ -1075,7 +1075,7 @@
 *******************************************************************************/
 static jint nativeNfcTag_doGetNdefType (JNIEnv*, jobject, jint libnfcType, jint javaType)
 {
-    ALOGD ("%s: enter; libnfc type=%d; java type=%d", __FUNCTION__, libnfcType, javaType);
+    ALOGD ("%s: enter; libnfc type=%d; java type=%d", __func__, libnfcType, javaType);
     jint ndefType = NDEF_UNKNOWN_TYPE;
 
     // For NFA, libnfcType is mapped to the protocol value received
@@ -1105,7 +1105,7 @@
         /* NFA_PROTOCOL_ISO15693, NFA_PROTOCOL_INVALID and others */
         ndefType = NDEF_UNKNOWN_TYPE;
     }
-    ALOGD ("%s: exit; ndef type=%d", __FUNCTION__, ndefType);
+    ALOGD ("%s: exit; ndef type=%d", __func__, ndefType);
     return ndefType;
 }
 
@@ -1136,20 +1136,20 @@
 
     if (!sCheckNdefWaitingForComplete)
     {
-        ALOGE ("%s: not waiting", __FUNCTION__);
+        ALOGE ("%s: not waiting", __func__);
         return;
     }
 
     if (flags & RW_NDEF_FL_READ_ONLY)
-        ALOGD ("%s: flag read-only", __FUNCTION__);
+        ALOGD ("%s: flag read-only", __func__);
     if (flags & RW_NDEF_FL_FORMATED)
-        ALOGD ("%s: flag formatted for ndef", __FUNCTION__);
+        ALOGD ("%s: flag formatted for ndef", __func__);
     if (flags & RW_NDEF_FL_SUPPORTED)
-        ALOGD ("%s: flag ndef supported", __FUNCTION__);
+        ALOGD ("%s: flag ndef supported", __func__);
     if (flags & RW_NDEF_FL_UNKNOWN)
-        ALOGD ("%s: flag all unknown", __FUNCTION__);
+        ALOGD ("%s: flag all unknown", __func__);
     if (flags & RW_NDEF_FL_FORMATABLE)
-        ALOGD ("%s: flag formattable", __FUNCTION__);
+        ALOGD ("%s: flag formattable", __func__);
 
     sCheckNdefWaitingForComplete = JNI_FALSE;
     sCheckNdefStatus = status;
@@ -1178,7 +1178,7 @@
     }
     else
     {
-        ALOGE ("%s: unknown status=0x%X", __FUNCTION__, status);
+        ALOGE ("%s: unknown status=0x%X", __func__, status);
         sCheckNdefMaxSize = 0;
         sCheckNdefCurrentSize = 0;
         sCheckNdefCardReadOnly = false;
@@ -1204,12 +1204,12 @@
     tNFA_STATUS status = NFA_STATUS_FAILED;
     jint* ndef = NULL;
 
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
 
     // special case for Kovio
     if (sCurrentConnectedTargetProtocol == TARGET_TYPE_KOVIO_BARCODE)
     {
-        ALOGD ("%s: Kovio tag, no NDEF", __FUNCTION__);
+        ALOGD ("%s: Kovio tag, no NDEF", __func__);
         ndef = e->GetIntArrayElements (ndefInfo, 0);
         ndef[0] = 0;
         ndef[1] = NDEF_MODE_READ_ONLY;
@@ -1224,17 +1224,17 @@
     /* Create the write semaphore */
     if (sem_init (&sCheckNdefSem, 0, 0) == -1)
     {
-        ALOGE ("%s: Check NDEF semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Check NDEF semaphore creation failed (errno=0x%08x)", __func__, errno);
         return JNI_FALSE;
     }
 
     if (NfcTag::getInstance ().getActivationState () != NfcTag::Active)
     {
-        ALOGE ("%s: tag already deactivated", __FUNCTION__);
+        ALOGE ("%s: tag already deactivated", __func__);
         goto TheEnd;
     }
 
-    ALOGD ("%s: try NFA_RwDetectNDef", __FUNCTION__);
+    ALOGD ("%s: try NFA_RwDetectNDef", __func__);
     sCheckNdefWaitingForComplete = JNI_TRUE;
 
     if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
@@ -1248,14 +1248,14 @@
 
     if (status != NFA_STATUS_OK)
     {
-        ALOGE ("%s: NFA_RwDetectNDef failed, status = 0x%X", __FUNCTION__, status);
+        ALOGE ("%s: NFA_RwDetectNDef failed, status = 0x%X", __func__, status);
         goto TheEnd;
     }
 
     /* Wait for check NDEF completion status */
     if (sem_wait (&sCheckNdefSem))
     {
-        ALOGE ("%s: Failed to wait for check NDEF semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to wait for check NDEF semaphore (errno=0x%08x)", __func__, errno);
         goto TheEnd;
     }
 
@@ -1296,7 +1296,7 @@
     }
     else
     {
-        ALOGD ("%s: unknown status 0x%X", __FUNCTION__, sCheckNdefStatus);
+        ALOGD ("%s: unknown status 0x%X", __func__, sCheckNdefStatus);
         status = sCheckNdefStatus;
     }
 
@@ -1310,10 +1310,10 @@
     /* Destroy semaphore */
     if (sem_destroy (&sCheckNdefSem))
     {
-        ALOGE ("%s: Failed to destroy check NDEF semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to destroy check NDEF semaphore (errno=0x%08x)", __func__, errno);
     }
     sCheckNdefWaitingForComplete = JNI_FALSE;
-    ALOGD ("%s: exit; status=0x%X", __FUNCTION__, status);
+    ALOGD ("%s: exit; status=0x%X", __func__, status);
     return status;
 }
 
@@ -1364,7 +1364,7 @@
 *******************************************************************************/
 static jboolean nativeNfcTag_doPresenceCheck (JNIEnv*, jobject)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     tNFA_STATUS status = NFA_STATUS_OK;
     jboolean isPresent = JNI_FALSE;
 
@@ -1373,7 +1373,7 @@
     // want to process as if the deactivate just happened.
     if (sCurrentConnectedTargetProtocol == TARGET_TYPE_KOVIO_BARCODE)
     {
-        ALOGD ("%s: Kovio, force deactivate handling", __FUNCTION__);
+        ALOGD ("%s: Kovio, force deactivate handling", __func__);
         tNFA_DEACTIVATED deactivated = {NFA_DEACTIVATE_TYPE_IDLE};
         {
             SyncEventGuard g (gDeactivatedEvent);
@@ -1392,13 +1392,13 @@
 
     if (nfcManager_isNfcActive() == false)
     {
-        ALOGD ("%s: NFC is no longer active.", __FUNCTION__);
+        ALOGD ("%s: NFC is no longer active.", __func__);
         return JNI_FALSE;
     }
 
     if (!sRfInterfaceMutex.tryLock())
     {
-        ALOGD ("%s: tag is being reSelected assume it is present", __FUNCTION__);
+        ALOGD ("%s: tag is being reSelected assume it is present", __func__);
         return JNI_TRUE;
     }
 
@@ -1406,7 +1406,7 @@
 
     if (NfcTag::getInstance ().isActivated () == false)
     {
-        ALOGD ("%s: tag already deactivated", __FUNCTION__);
+        ALOGD ("%s: tag already deactivated", __func__);
         return JNI_FALSE;
     }
     if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
@@ -1429,7 +1429,7 @@
     }
 
     if (isPresent == JNI_FALSE)
-        ALOGD ("%s: tag absent", __FUNCTION__);
+        ALOGD ("%s: tag absent", __func__);
     return isPresent;
 }
 
@@ -1508,7 +1508,7 @@
         }
     }
 
-    ALOGD("%s: is formattable=%u", __FUNCTION__, isFormattable);
+    ALOGD("%s: is formattable=%u", __func__, isFormattable);
     return isFormattable;
 }
 
@@ -1529,7 +1529,7 @@
 static jboolean nativeNfcTag_doIsIsoDepNdefFormatable (JNIEnv *e, jobject o, jbyteArray pollBytes, jbyteArray actBytes)
 {
     uint8_t uidFake[] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     jbyteArray uidArray = e->NewByteArray (8);
     e->SetByteArrayRegion (uidArray, 0, 8, (jbyte*) uidFake);
     return nativeNfcTag_doIsNdefFormatable (e, o, 0, uidArray, pollBytes, actBytes);
@@ -1551,13 +1551,13 @@
 *******************************************************************************/
 static jboolean nativeNfcTag_makeMifareNdefFormat (JNIEnv *e, jobject o, uint8_t *key, uint32_t keySize)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     tNFA_STATUS status = NFA_STATUS_OK;
 
     status = nativeNfcTag_doReconnect (e, o);
     if (status != NFA_STATUS_OK)
     {
-        ALOGD ("%s: reconnect error, status=%u", __FUNCTION__, status);
+        ALOGD ("%s: reconnect error, status=%u", __func__, status);
         return JNI_FALSE;
     }
 
@@ -1568,17 +1568,17 @@
 
     if (status == NFA_STATUS_OK)
     {
-        ALOGD ("%s: wait for completion", __FUNCTION__);
+        ALOGD ("%s: wait for completion", __func__);
         sem_wait (&sFormatSem);
         status = sFormatOk ? NFA_STATUS_OK : NFA_STATUS_FAILED;
     }
     else
     {
-        ALOGE ("%s: error status=%u", __FUNCTION__, status);
+        ALOGE ("%s: error status=%u", __func__, status);
     }
 
     sem_destroy (&sFormatSem);
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return (status == NFA_STATUS_OK) ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -1597,13 +1597,13 @@
 *******************************************************************************/
 static jboolean nativeNfcTag_doNdefFormat (JNIEnv *e, jobject o, jbyteArray)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     tNFA_STATUS status = NFA_STATUS_OK;
 
     // Do not try to format if tag is already deactivated.
     if (NfcTag::getInstance ().isActivated () == false)
     {
-        ALOGD ("%s: tag already deactivated(no need to format)", __FUNCTION__);
+        ALOGD ("%s: tag already deactivated(no need to format)", __func__);
         return JNI_FALSE;
     }
 
@@ -1626,12 +1626,12 @@
     status = NFA_RwFormatTag ();
     if (status == NFA_STATUS_OK)
     {
-        ALOGD ("%s: wait for completion", __FUNCTION__);
+        ALOGD ("%s: wait for completion", __func__);
         sem_wait (&sFormatSem);
         status = sFormatOk ? NFA_STATUS_OK : NFA_STATUS_FAILED;
     }
     else
-        ALOGE ("%s: error status=%u", __FUNCTION__, status);
+        ALOGE ("%s: error status=%u", __func__, status);
     sem_destroy (&sFormatSem);
 
     if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_ISO_DEP)
@@ -1639,7 +1639,7 @@
         int retCode = NFCSTATUS_SUCCESS;
         retCode = nativeNfcTag_doReconnect (e, o);
     }
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return (status == NFA_STATUS_OK) ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -1687,12 +1687,12 @@
 
     sMakeReadonlyStatus = NFA_STATUS_FAILED;
 
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
 
     /* Create the make_readonly semaphore */
     if (sem_init (&sMakeReadonlySem, 0, 0) == -1)
     {
-        ALOGE ("%s: Make readonly semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Make readonly semaphore creation failed (errno=0x%08x)", __func__, errno);
         return JNI_FALSE;
     }
 
@@ -1720,7 +1720,7 @@
     /* Destroy semaphore */
     if (sem_destroy (&sMakeReadonlySem))
     {
-        ALOGE ("%s: Failed to destroy read_only semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to destroy read_only semaphore (errno=0x%08x)", __func__, errno);
     }
     sMakeReadonlyWaitingForComplete = JNI_FALSE;
     return result;
@@ -1744,7 +1744,7 @@
     jboolean result = JNI_FALSE;
     tNFA_STATUS status;
 
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
 
     if (sCurrentConnectedTargetProtocol == NFA_PROTOCOL_MIFARE)
     {
@@ -1761,7 +1761,7 @@
     /* Create the make_readonly semaphore */
     if (sem_init (&sMakeReadonlySem, 0, 0) == -1)
     {
-        ALOGE ("%s: Make readonly semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Make readonly semaphore creation failed (errno=0x%08x)", __func__, errno);
         return JNI_FALSE;
     }
 
@@ -1774,20 +1774,20 @@
         status = NFA_RwSetTagReadOnly (FALSE); //try soft lock
         if (status != NFA_STATUS_OK)
         {
-            ALOGE ("%s: fail soft lock, status=%d", __FUNCTION__, status);
+            ALOGE ("%s: fail soft lock, status=%d", __func__, status);
             goto TheEnd;
         }
     }
     else if (status != NFA_STATUS_OK)
     {
-        ALOGE ("%s: fail hard lock, status=%d", __FUNCTION__, status);
+        ALOGE ("%s: fail hard lock, status=%d", __func__, status);
         goto TheEnd;
     }
 
     /* Wait for check NDEF completion status */
     if (sem_wait (&sMakeReadonlySem))
     {
-        ALOGE ("%s: Failed to wait for make_readonly semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to wait for make_readonly semaphore (errno=0x%08x)", __func__, errno);
         goto TheEnd;
     }
 
@@ -1800,7 +1800,7 @@
     /* Destroy semaphore */
     if (sem_destroy (&sMakeReadonlySem))
     {
-        ALOGE ("%s: Failed to destroy read_only semaphore (errno=0x%08x)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to destroy read_only semaphore (errno=0x%08x)", __func__, errno);
     }
     sMakeReadonlyWaitingForComplete = JNI_FALSE;
     return result;
@@ -1821,9 +1821,9 @@
 //from the NFA_NDEF_DATA_EVT;
 void nativeNfcTag_registerNdefTypeHandler ()
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     sNdefTypeHandlerHandle = NFA_HANDLE_INVALID;
-    NFA_RegisterNDefTypeHandler (TRUE, NFA_TNF_DEFAULT, (UINT8 *) "", 0, ndefHandlerCallback);
+    NFA_RegisterNDefTypeHandler (TRUE, NFA_TNF_DEFAULT, (uint8_t *) "", 0, ndefHandlerCallback);
     EXTNS_MfcRegisterNDefTypeHandler (ndefHandlerCallback);
 }
 
@@ -1839,7 +1839,7 @@
 *******************************************************************************/
 void nativeNfcTag_deregisterNdefTypeHandler ()
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     NFA_DeregisterNDefTypeHandler (sNdefTypeHandlerHandle);
     sNdefTypeHandlerHandle = NFA_HANDLE_INVALID;
 }
@@ -1880,7 +1880,7 @@
 *******************************************************************************/
 int register_com_android_nfc_NativeNfcTag (JNIEnv *e)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     return jniRegisterNativeMethods (e, gNativeNfcTagClassName, gMethods, NELEM (gMethods));
 }
 
diff --git a/nci/jni/NativeP2pDevice.cpp b/nci/jni/NativeP2pDevice.cpp
index 71b3072..d649087 100644
--- a/nci/jni/NativeP2pDevice.cpp
+++ b/nci/jni/NativeP2pDevice.cpp
@@ -28,35 +28,35 @@
 
 static jboolean nativeP2pDeviceDoConnect (JNIEnv*, jobject)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     return JNI_TRUE;
 }
 
 
 static jboolean nativeP2pDeviceDoDisconnect (JNIEnv*, jobject)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     return JNI_TRUE;
 }
 
 
 static jbyteArray nativeP2pDeviceDoTransceive (JNIEnv*, jobject, jbyteArray)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     return NULL;
 }
 
 
 static jbyteArray nativeP2pDeviceDoReceive (JNIEnv*, jobject)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     return NULL;
 }
 
 
 static jboolean nativeP2pDeviceDoSend (JNIEnv*, jobject, jbyteArray)
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     return JNI_TRUE;
 }
 
diff --git a/nci/jni/NfcJniUtil.cpp b/nci/jni/NfcJniUtil.cpp
index 2c75593..a5eacef 100755
--- a/nci/jni/NfcJniUtil.cpp
+++ b/nci/jni/NfcJniUtil.cpp
@@ -37,7 +37,7 @@
 *******************************************************************************/
 jint JNI_OnLoad (JavaVM* jvm, void*)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     JNIEnv *e = NULL;
 
     ALOGI("NFC Service: loading nci JNI");
@@ -60,7 +60,7 @@
         return JNI_ERR;
     if (RoutingManager::getInstance().registerJniFunctions (e) == -1)
         return JNI_ERR;
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
     return JNI_VERSION_1_6;
 }
 
@@ -83,7 +83,7 @@
     ScopedLocalRef<jclass> cls(e, e->FindClass(className));
     if (cls.get() == NULL)
     {
-        ALOGE("%s: find class error", __FUNCTION__);
+        ALOGE("%s: find class error", __func__);
         return -1;
     }
 
@@ -91,14 +91,14 @@
     ScopedLocalRef<jobject> obj(e, e->NewObject(cls.get(), ctor));
     if (obj.get() == NULL)
     {
-       ALOGE("%s: create object error", __FUNCTION__);
+       ALOGE("%s: create object error", __func__);
        return -1;
     }
 
     *cachedObj = e->NewGlobalRef(obj.get());
     if (*cachedObj == NULL)
     {
-        ALOGE("%s: global ref error", __FUNCTION__);
+        ALOGE("%s: global ref error", __func__);
         return -1;
     }
     return 0;
@@ -158,7 +158,7 @@
     ScopedLocalRef<jclass> cls(e, e->FindClass(className));
     if(cls.get() == NULL)
     {
-        ALOGE ("%s: find class error", __FUNCTION__);
+        ALOGE ("%s: find class error", __func__);
         return -1;
     }
 
@@ -166,14 +166,14 @@
     jobject obj = e->NewObject(cls.get(), ctor);
     if (obj == NULL)
     {
-       ALOGE ("%s: create object error", __FUNCTION__);
+       ALOGE ("%s: create object error", __func__);
        return -1;
     }
 
     *cachedObj = obj;
     if (*cachedObj == NULL)
     {
-        ALOGE ("%s: global ref error", __FUNCTION__);
+        ALOGE ("%s: global ref error", __func__);
         return -1;
     }
     return 0;
diff --git a/nci/jni/NfcTag.cpp b/nci/jni/NfcTag.cpp
index c6e074b..7a77e23 100755
--- a/nci/jni/NfcTag.cpp
+++ b/nci/jni/NfcTag.cpp
@@ -214,7 +214,7 @@
 ** Returns          Time difference in milliseconds
 **
 *******************************************************************************/
-UINT32 TimeDiff(timespec start, timespec end)
+uint32_t TimeDiff(timespec start, timespec end)
 {
     timespec temp;
     if ((end.tv_nsec-start.tv_nsec)<0)
@@ -341,7 +341,7 @@
     }
     else if (NFC_PROTOCOL_T3T == rfDetail.protocol)
     {
-        UINT8 xx = 0;
+        uint8_t xx = 0;
 
         mTechList [mNumTechList] = TARGET_TYPE_FELICA;
 
@@ -762,7 +762,7 @@
             System Code: 2 bytes;
             ****************/
             ALOGD ("%s: tech F", fn);
-            UINT8 result [10]; //return result to NFC service
+            uint8_t result [10]; //return result to NFC service
             memset (result, 0, sizeof(result));
             len =  10;
 
@@ -776,9 +776,9 @@
             memcpy (result, mTechParams [i].param.pf.sensf_res + 8, 8); //copy PMm
             if (activationData.params.t3t.num_system_codes > 0) //copy the first System Code
             {
-                UINT16 systemCode = *(activationData.params.t3t.p_system_codes);
-                result [8] = (UINT8) (systemCode >> 8);
-                result [9] = (UINT8) systemCode;
+                uint16_t systemCode = *(activationData.params.t3t.p_system_codes);
+                result [8] = (uint8_t) (systemCode >> 8);
+                result [9] = (uint8_t) systemCode;
                 ALOGD ("%s: tech F; sys code=0x%X 0x%X", fn, result [8], result [9]);
             }
             pollBytes.reset(e->NewByteArray(len));
@@ -1065,7 +1065,7 @@
 void NfcTag::selectP2p()
 {
     static const char fn [] = "NfcTag::selectP2p";
-    UINT8 rfDiscoveryId = 0;
+    uint8_t rfDiscoveryId = 0;
 
     for (int i = 0; i < mNumTechList; i++)
     {
@@ -1336,7 +1336,7 @@
 ** Returns:         True if the response is NACK
 **
 *******************************************************************************/
-bool NfcTag::isT2tNackResponse (const UINT8* response, UINT32 responseLen)
+bool NfcTag::isT2tNackResponse (const uint8_t* response, uint32_t responseLen)
 {
     static const char fn [] = "NfcTag::isT2tNackResponse";
     bool isNack = false;
@@ -1379,7 +1379,7 @@
 ** Returns:         None
 **
 *******************************************************************************/
-void NfcTag::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* data)
+void NfcTag::connectionEventHandler (uint8_t event, tNFA_CONN_EVT_DATA* data)
 {
     static const char fn [] = "NfcTag::connectionEventHandler";
 
@@ -1575,7 +1575,7 @@
             //Short Product Information, 2011-11-24, section 3.5
             if (mTechParams[i].param.pa.nfcid1[0] == 0x05)
             {
-                UINT8 highNibble = mTechParams[i].param.pa.nfcid1[1] & 0xF0;
+                uint8_t highNibble = mTechParams[i].param.pa.nfcid1[1] & 0xF0;
                 if (highNibble == 0x30)
                     retval = true;
             }
diff --git a/nci/jni/NfcTag.h b/nci/jni/NfcTag.h
index df7ce0c..2e7721d 100755
--- a/nci/jni/NfcTag.h
+++ b/nci/jni/NfcTag.h
@@ -97,7 +97,7 @@
     ** Returns:         None
     **
     *******************************************************************************/
-    void connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* data);
+    void connectionEventHandler (uint8_t event, tNFA_CONN_EVT_DATA* data);
 
 
     /*******************************************************************************
@@ -257,7 +257,7 @@
     ** Returns:         True if the response is NACK
     **
     *******************************************************************************/
-    bool isT2tNackResponse (const UINT8* response, UINT32 responseLen);
+    bool isT2tNackResponse (const uint8_t* response, uint32_t responseLen);
 
     /*******************************************************************************
     **
@@ -398,7 +398,7 @@
     tNFC_RF_TECH_PARAMS mTechParams [MAX_NUM_TECHNOLOGY]; //array of technology parameters
     SyncEvent mReadCompleteEvent;
     struct timespec mLastKovioTime; // time of last Kovio tag activation
-    UINT8 mLastKovioUid[NFC_KOVIO_MAX_LEN]; // uid of last Kovio tag activated
+    uint8_t mLastKovioUid[NFC_KOVIO_MAX_LEN]; // uid of last Kovio tag activated
     bool mIsDynamicTagId; // whether the tag has dynamic tag ID
     tNFA_RW_PRES_CHK_OPTION mPresenceCheckAlgorithm;
     bool mIsFelicaLite;
diff --git a/nci/jni/PeerToPeer.cpp b/nci/jni/PeerToPeer.cpp
index 8074f69..fe48d41 100644
--- a/nci/jni/PeerToPeer.cpp
+++ b/nci/jni/PeerToPeer.cpp
@@ -529,7 +529,7 @@
 ** Returns:         True if ok.
 **
 *******************************************************************************/
-bool PeerToPeer::createClient (tJNI_HANDLE jniHandle, UINT16 miu, UINT8 rw)
+bool PeerToPeer::createClient (tJNI_HANDLE jniHandle, uint16_t miu, uint8_t rw)
 {
     static const char fn [] = "PeerToPeer::createClient";
     int i = 0;
@@ -655,7 +655,7 @@
 ** Returns:         True if ok.
 **
 *******************************************************************************/
-bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, UINT8 destinationSap)
+bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, uint8_t destinationSap)
 {
     static const char fn [] = "PeerToPeer::connectConnOriented";
     ALOGD ("%s: enter; h: %u  dest sap: 0x%X", fn, jniHandle, destinationSap);
@@ -677,7 +677,7 @@
 ** Returns:         True if ok.
 **
 *******************************************************************************/
-bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, UINT8 destinationSap)
+bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, uint8_t destinationSap)
 {
     static const char fn [] = "PeerToPeer::createDataLinkConn";
     ALOGD ("%s: enter", fn);
@@ -885,7 +885,7 @@
 ** Returns:         True if ok.
 **
 *******************************************************************************/
-bool PeerToPeer::send (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen)
+bool PeerToPeer::send (tJNI_HANDLE jniHandle, uint8_t *buffer, uint16_t bufferLen)
 {
     static const char fn [] = "PeerToPeer::send";
     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
@@ -939,14 +939,14 @@
 ** Returns:         True if ok.
 **
 *******************************************************************************/
-bool PeerToPeer::receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen, UINT16& actualLen)
+bool PeerToPeer::receive (tJNI_HANDLE jniHandle, uint8_t* buffer, uint16_t bufferLen, uint16_t& actualLen)
 {
     static const char fn [] = "PeerToPeer::receive";
     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; jniHandle: %u  bufferLen: %u", fn, jniHandle, bufferLen);
     sp<NfaConn> pConn = NULL;
     tNFA_STATUS stat = NFA_STATUS_FAILED;
-    UINT32 actualDataLen2 = 0;
-    BOOLEAN isMoreData = TRUE;
+    uint32_t actualDataLen2 = 0;
+    bool    isMoreData = TRUE;
     bool retVal = false;
 
     if ((pConn = findConnection (jniHandle)) == NULL)
@@ -963,7 +963,7 @@
         stat = NFA_P2pReadData (pConn->mNfaConnHandle, bufferLen, &actualDataLen2, buffer, &isMoreData);
         if ((stat == NFA_STATUS_OK) && (actualDataLen2 > 0)) //received some data
         {
-            actualLen = (UINT16) actualDataLen2;
+            actualLen = (uint16_t) actualDataLen2;
             retVal = true;
             break;
         }
@@ -1052,7 +1052,7 @@
 ** Returns:         Peer's max information unit.
 **
 *******************************************************************************/
-UINT16 PeerToPeer::getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle)
+uint16_t PeerToPeer::getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle)
 {
     static const char fn [] = "PeerToPeer::getRemoteMaxInfoUnit";
     sp<NfaConn> pConn = NULL;
@@ -1077,7 +1077,7 @@
 ** Returns:         Peer's receive window size.
 **
 *******************************************************************************/
-UINT8 PeerToPeer::getRemoteRecvWindow (tJNI_HANDLE jniHandle)
+uint8_t PeerToPeer::getRemoteRecvWindow (tJNI_HANDLE jniHandle)
 {
     static const char fn [] = "PeerToPeer::getRemoteRecvWindow";
     ALOGD ("%s: client jni handle: %u", fn, jniHandle);
@@ -1571,7 +1571,7 @@
 ** Returns:         None
 **
 *******************************************************************************/
-void PeerToPeer::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* /*eventData*/)
+void PeerToPeer::connectionEventHandler (uint8_t event, tNFA_CONN_EVT_DATA* /*eventData*/)
 {
     switch (event)
     {
@@ -1632,7 +1632,7 @@
     static const char fn [] = "P2pServer::registerWithStack";
     ALOGD ("%s: enter; service name: %s  JNI handle: %u", fn, mServiceName.c_str(), mJniHandle);
     tNFA_STATUS     stat  = NFA_STATUS_OK;
-    UINT8           serverSap = NFA_P2P_ANY_SAP;
+    uint8_t         serverSap = NFA_P2P_ANY_SAP;
 
     /**********************
    default values for all LLCP parameters:
diff --git a/nci/jni/PeerToPeer.h b/nci/jni/PeerToPeer.h
index 3fb97a6..53b554b 100644
--- a/nci/jni/PeerToPeer.h
+++ b/nci/jni/PeerToPeer.h
@@ -133,7 +133,7 @@
     ** Returns:         None
     **
     *******************************************************************************/
-    void connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* eventData);
+    void connectionEventHandler (uint8_t event, tNFA_CONN_EVT_DATA* eventData);
 
 
     /*******************************************************************************
@@ -190,7 +190,7 @@
     ** Returns:         True if ok.
     **
     *******************************************************************************/
-    bool createClient (tJNI_HANDLE jniHandle, UINT16 miu, UINT8 rw);
+    bool createClient (tJNI_HANDLE jniHandle, uint16_t miu, uint8_t rw);
 
 
     /*******************************************************************************
@@ -218,7 +218,7 @@
     ** Returns:         True if ok.
     **
     *******************************************************************************/
-    bool connectConnOriented (tJNI_HANDLE jniHandle, UINT8 destinationSap);
+    bool connectConnOriented (tJNI_HANDLE jniHandle, uint8_t destinationSap);
 
 
     /*******************************************************************************
@@ -233,7 +233,7 @@
     ** Returns:         True if ok.
     **
     *******************************************************************************/
-    bool send (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen);
+    bool send (tJNI_HANDLE jniHandle, uint8_t* buffer, uint16_t bufferLen);
 
 
     /*******************************************************************************
@@ -249,7 +249,7 @@
     ** Returns:         True if ok.
     **
     *******************************************************************************/
-    bool receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen, UINT16& actualLen);
+    bool receive (tJNI_HANDLE jniHandle, uint8_t* buffer, uint16_t bufferLen, uint16_t& actualLen);
 
 
     /*******************************************************************************
@@ -275,7 +275,7 @@
     ** Returns:         Peer's max information unit.
     **
     *******************************************************************************/
-    UINT16 getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle);
+    uint16_t getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle);
 
 
     /*******************************************************************************
@@ -288,7 +288,7 @@
     ** Returns:         Peer's receive window size.
     **
     *******************************************************************************/
-    UINT8 getRemoteRecvWindow (tJNI_HANDLE jniHandle);
+    uint8_t getRemoteRecvWindow (tJNI_HANDLE jniHandle);
 
 
     /*******************************************************************************
@@ -396,7 +396,7 @@
     static PeerToPeer sP2p;
 
     // Variables below only accessed from a single thread
-    UINT16          mRemoteWKS;                 // Peer's well known services
+    uint16_t        mRemoteWKS;                 // Peer's well known services
     bool            mIsP2pListening;            // If P2P listening is enabled or not
     tNFA_TECHNOLOGY_MASK    mP2pListenTechMask; // P2P Listen mask
 
@@ -509,7 +509,7 @@
     ** Returns:         True if ok.
     **
     *******************************************************************************/
-    bool        createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, UINT8 destinationSap);
+    bool        createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, uint8_t destinationSap);
 
 
     /*******************************************************************************
@@ -590,10 +590,10 @@
 public:
     tNFA_HANDLE         mNfaConnHandle;         // NFA handle of the P2P connection
     PeerToPeer::tJNI_HANDLE         mJniHandle;             // JNI handle of the P2P connection
-    UINT16              mMaxInfoUnit;
-    UINT8               mRecvWindow;
-    UINT16              mRemoteMaxInfoUnit;
-    UINT8               mRemoteRecvWindow;
+    uint16_t            mMaxInfoUnit;
+    uint8_t             mRecvWindow;
+    uint16_t            mRemoteMaxInfoUnit;
+    uint8_t             mRemoteRecvWindow;
     SyncEvent           mReadEvent;             // event for reading
     SyncEvent           mCongEvent;             // event for congestion
     SyncEvent           mDisconnectingEvent;     // event for disconnecting
diff --git a/nci/jni/Pn544Interop.cpp b/nci/jni/Pn544Interop.cpp
index 31dce20..e6df16e 100644
--- a/nci/jni/Pn544Interop.cpp
+++ b/nci/jni/Pn544Interop.cpp
@@ -59,7 +59,7 @@
 *******************************************************************************/
 void pn544InteropStopPolling ()
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     gMutex.lock ();
     gTimer.kill ();
     android::startStopPolling (false);
@@ -67,7 +67,7 @@
     gAbortNow = false;
     gTimer.set (gIntervalTime, pn544InteropStartPolling); //after some time, start polling again
     gMutex.unlock ();
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
 }
 
 
@@ -83,32 +83,32 @@
 *******************************************************************************/
 void pn544InteropStartPolling (union sigval)
 {
-    ALOGD ("%s: enter", __FUNCTION__);
+    ALOGD ("%s: enter", __func__);
     gMutex.lock ();
     NfcTag::ActivationState state = NfcTag::getInstance ().getActivationState ();
 
     if (gAbortNow)
     {
-        ALOGD ("%s: abort now", __FUNCTION__);
+        ALOGD ("%s: abort now", __func__);
         gIsBusy = false;
         goto TheEnd;
     }
 
     if (state == NfcTag::Idle)
     {
-        ALOGD ("%s: start polling", __FUNCTION__);
+        ALOGD ("%s: start polling", __func__);
         android::startStopPolling (true);
         gIsBusy = false;
     }
     else
     {
-        ALOGD ("%s: try again later", __FUNCTION__);
+        ALOGD ("%s: try again later", __func__);
         gTimer.set (gIntervalTime, pn544InteropStartPolling); //after some time, start polling again
     }
 
 TheEnd:
     gMutex.unlock ();
-    ALOGD ("%s: exit", __FUNCTION__);
+    ALOGD ("%s: exit", __func__);
 }
 
 
@@ -127,7 +127,7 @@
     gMutex.lock ();
     isBusy = gIsBusy;
     gMutex.unlock ();
-    ALOGD ("%s: %u", __FUNCTION__, isBusy);
+    ALOGD ("%s: %u", __func__, isBusy);
     return isBusy;
 }
 
@@ -143,7 +143,7 @@
 *******************************************************************************/
 void pn544InteropAbortNow ()
 {
-    ALOGD ("%s", __FUNCTION__);
+    ALOGD ("%s", __func__);
     gMutex.lock ();
     gAbortNow = true;
     gMutex.unlock ();
diff --git a/nci/jni/PowerSwitch.cpp b/nci/jni/PowerSwitch.cpp
index cf320b5..9245522 100755
--- a/nci/jni/PowerSwitch.cpp
+++ b/nci/jni/PowerSwitch.cpp
@@ -373,7 +373,7 @@
 ** Returns:         Text representation of power level.
 **
 *******************************************************************************/
-const char* PowerSwitch::deviceMgtPowerStateToString (UINT8 deviceMgtPowerState)
+const char* PowerSwitch::deviceMgtPowerStateToString (uint8_t deviceMgtPowerState)
 {
     switch (deviceMgtPowerState)
     {
@@ -468,7 +468,7 @@
 ** Returns:         None
 **
 *******************************************************************************/
-void PowerSwitch::deviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA* eventData)
+void PowerSwitch::deviceManagementCallback (uint8_t event, tNFA_DM_CBACK_DATA* eventData)
 {
     static const char fn [] = "PowerSwitch::deviceManagementCallback";
 
diff --git a/nci/jni/PowerSwitch.h b/nci/jni/PowerSwitch.h
index 1324c50..ae9986f 100755
--- a/nci/jni/PowerSwitch.h
+++ b/nci/jni/PowerSwitch.h
@@ -221,7 +221,7 @@
     ** Returns:         None
     **
     *******************************************************************************/
-    static void deviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA* eventData);
+    static void deviceManagementCallback (uint8_t event, tNFA_DM_CBACK_DATA* eventData);
 
 
     /*******************************************************************************
@@ -237,11 +237,11 @@
 
 private:
     PowerLevel mCurrLevel;
-    UINT8 mCurrDeviceMgtPowerState; //device management power state; such as NFA_BRCM_PWR_MODE_???
-    UINT8 mExpectedDeviceMgtPowerState; //device management power state; such as NFA_BRCM_PWR_MODE_???
+    uint8_t mCurrDeviceMgtPowerState; //device management power state; such as NFA_BRCM_PWR_MODE_???
+    uint8_t mExpectedDeviceMgtPowerState; //device management power state; such as NFA_BRCM_PWR_MODE_???
     int mDesiredScreenOffPowerState; //read from .conf file; 0=power-off-sleep; 1=full power; 2=CE4 power
     static PowerSwitch sPowerSwitch; //singleton object
-    static const UINT8 NFA_DM_PWR_STATE_UNKNOWN = -1; //device management power state power state is unknown
+    static const uint8_t NFA_DM_PWR_STATE_UNKNOWN = -1; //device management power state power state is unknown
     SyncEvent mPowerStateEvent;
     PowerActivity mCurrActivity;
     Mutex mMutex;
@@ -270,7 +270,7 @@
     ** Returns:         Text representation of power level.
     **
     *******************************************************************************/
-    const char* deviceMgtPowerStateToString (UINT8 deviceMgtPowerState);
+    const char* deviceMgtPowerStateToString (uint8_t deviceMgtPowerState);
 
 
     /*******************************************************************************
diff --git a/nci/jni/RouteDataSet.cpp b/nci/jni/RouteDataSet.cpp
index bb259b3..da2ae5c 100644
--- a/nci/jni/RouteDataSet.cpp
+++ b/nci/jni/RouteDataSet.cpp
@@ -47,21 +47,21 @@
     std::string::size_type pos2 = aid.find_first_of (delimiter);
 
     //parse the AID string; each hex number is separated by a colon;
-    mBuffer = new UINT8 [aid.length()];
+    mBuffer = new uint8_t [aid.length()];
     while (true)
     {
         num = 0;
         if (pos2 == std::string::npos)
         {
             sscanf (aid.substr(pos1).c_str(), "%x", &num);
-            mBuffer [mBufferLen] = (UINT8) num;
+            mBuffer [mBufferLen] = (uint8_t) num;
             mBufferLen++;
             break;
         }
         else
         {
             sscanf (aid.substr(pos1, pos2-pos1+1).c_str(), "%x", &num);
-            mBuffer [mBufferLen] = (UINT8) num;
+            mBuffer [mBufferLen] = (uint8_t) num;
             mBufferLen++;
             pos1 = pos2 + 1;
             pos2 = aid.find_first_of (delimiter, pos1);
diff --git a/nci/jni/RouteDataSet.h b/nci/jni/RouteDataSet.h
index d2a09b8..eefcb41 100644
--- a/nci/jni/RouteDataSet.h
+++ b/nci/jni/RouteDataSet.h
@@ -134,12 +134,12 @@
     ~AidBuffer ();
 
 
-    UINT8* buffer () {return mBuffer;};
+    uint8_t* buffer () {return mBuffer;};
     int length () {return mBufferLen;};
 
 private:
-    UINT8* mBuffer;
-    UINT32 mBufferLen;
+    uint8_t* mBuffer;
+    uint32_t mBufferLen;
 };
 
 
diff --git a/nci/jni/RoutingManager.cpp b/nci/jni/RoutingManager.cpp
index d2f6964..3839ec3 100755
--- a/nci/jni/RoutingManager.cpp
+++ b/nci/jni/RoutingManager.cpp
@@ -136,7 +136,7 @@
         }
 
         ALOGD ("%s: Number of EE is %d", fn, mEeInfo.num_ee);
-        for (UINT8 i = 0; i < mEeInfo.num_ee; i++)
+        for (uint8_t i = 0; i < mEeInfo.num_ee; i++)
         {
             tNFA_HANDLE eeHandle = mEeInfo.ee_disc_info[i].ee_handle;
             tNFA_TECHNOLOGY_MASK seTechMask = 0;
@@ -326,11 +326,11 @@
     }
 }
 
-bool RoutingManager::addAidRouting(const UINT8* aid, UINT8 aidLen, int route)
+bool RoutingManager::addAidRouting(const uint8_t* aid, uint8_t aidLen, int route)
 {
     static const char fn [] = "RoutingManager::addAidRouting";
     ALOGD ("%s: enter", fn);
-    tNFA_STATUS nfaStat = NFA_EeAddAidRouting(route, aidLen, (UINT8*) aid, 0x01);
+    tNFA_STATUS nfaStat = NFA_EeAddAidRouting(route, aidLen, (uint8_t*) aid, 0x01);
     if (nfaStat == NFA_STATUS_OK)
     {
         ALOGD ("%s: routed AID", fn);
@@ -342,11 +342,11 @@
     }
 }
 
-bool RoutingManager::removeAidRouting(const UINT8* aid, UINT8 aidLen)
+bool RoutingManager::removeAidRouting(const uint8_t* aid, uint8_t aidLen)
 {
     static const char fn [] = "RoutingManager::removeAidRouting";
     ALOGD ("%s: enter", fn);
-    tNFA_STATUS nfaStat = NFA_EeRemoveAidRouting(aidLen, (UINT8*) aid);
+    tNFA_STATUS nfaStat = NFA_EeRemoveAidRouting(aidLen, (uint8_t*) aid);
     if (nfaStat == NFA_STATUS_OK)
     {
         ALOGD ("%s: removed AID", fn);
@@ -380,7 +380,7 @@
     if (mActiveSe == 0x00) return;
 
     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
-    UINT8 actualNumEe = MAX_NUM_EE;
+    uint8_t actualNumEe = MAX_NUM_EE;
     tNFA_EE_INFO eeInfo[MAX_NUM_EE];
 
     memset (&eeInfo, 0, sizeof(eeInfo));
@@ -391,7 +391,7 @@
     }
     if (actualNumEe != 0)
     {
-        for (UINT8 xx = 0; xx < actualNumEe; xx++)
+        for (uint8_t xx = 0; xx < actualNumEe; xx++)
         {
             if ((eeInfo[xx].num_interface != 0)
                 && (eeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS)
@@ -416,7 +416,7 @@
     }
 }
 
-void RoutingManager::notifyActivated (UINT8 technology)
+void RoutingManager::notifyActivated (uint8_t technology)
 {
     JNIEnv* e = NULL;
     ScopedAttach attach(mNativeData->vm, &e);
@@ -434,7 +434,7 @@
     }
 }
 
-void RoutingManager::notifyDeactivated (UINT8 technology)
+void RoutingManager::notifyDeactivated (uint8_t technology)
 {
     mRxDataBuffer.clear();
     JNIEnv* e = NULL;
@@ -453,7 +453,7 @@
     }
 }
 
-void RoutingManager::handleData (UINT8 technology, const UINT8* data, UINT32 dataLen, tNFA_STATUS status)
+void RoutingManager::handleData (uint8_t technology, const uint8_t* data, uint32_t dataLen, tNFA_STATUS status)
 {
     if (status == NFA_STATUS_CONTINUE)
     {
@@ -514,7 +514,7 @@
     mRxDataBuffer.clear();
 }
 
-void RoutingManager::stackCallback (UINT8 event, tNFA_CONN_EVT_DATA* eventData)
+void RoutingManager::stackCallback (uint8_t event, tNFA_CONN_EVT_DATA* eventData)
 {
     static const char fn [] = "RoutingManager::stackCallback";
     ALOGD("%s: event=0x%X", fn, event);
@@ -636,7 +636,7 @@
 
     case NFA_EE_DISCOVER_REQ_EVT:
         {
-            ALOGD ("%s: NFA_EE_DISCOVER_REQ_EVT; status=0x%X; num ee=%u", __FUNCTION__,
+            ALOGD ("%s: NFA_EE_DISCOVER_REQ_EVT; status=0x%X; num ee=%u", __func__,
                     eventData->discover_req.status, eventData->discover_req.num_ee);
             SyncEventGuard guard (routingManager.mEeInfoEvent);
             memcpy (&routingManager.mEeInfo, &eventData->discover_req, sizeof(routingManager.mEeInfo));
@@ -682,7 +682,7 @@
     }
 }
 
-int RoutingManager::registerT3tIdentifier(UINT8* t3tId, UINT8 t3tIdLen)
+int RoutingManager::registerT3tIdentifier(uint8_t* t3tId, uint8_t t3tIdLen)
 {
     static const char fn [] = "RoutingManager::registerT3tIdentifier";
 
@@ -698,7 +698,7 @@
     mNfcFOnDhHandle = NFA_HANDLE_INVALID;
 
     int systemCode;
-    UINT8 nfcid2[NCI_RF_F_UID_LEN];
+    uint8_t nfcid2[NCI_RF_F_UID_LEN];
 
     systemCode = (((int)t3tId[0] << 8) | ((int)t3tId[1] << 0));
     memcpy(nfcid2, t3tId + 2, NCI_RF_F_UID_LEN);
@@ -738,12 +738,12 @@
     }
 }
 
-void RoutingManager::nfcFCeCallback (UINT8 event, tNFA_CONN_EVT_DATA* eventData)
+void RoutingManager::nfcFCeCallback (uint8_t event, tNFA_CONN_EVT_DATA* eventData)
 {
     static const char fn [] = "RoutingManager::nfcFCeCallback";
     RoutingManager& routingManager = RoutingManager::getInstance();
 
-    ALOGD("%s: 0x%x", __FUNCTION__, event);
+    ALOGD("%s: 0x%x", __func__, event);
 
     switch (event)
     {
diff --git a/nci/jni/RoutingManager.h b/nci/jni/RoutingManager.h
index f6d4639..ee9211f 100755
--- a/nci/jni/RoutingManager.h
+++ b/nci/jni/RoutingManager.h
@@ -35,10 +35,10 @@
     bool initialize(nfc_jni_native_data* native);
     void enableRoutingToHost();
     void disableRoutingToHost();
-    bool addAidRouting(const UINT8* aid, UINT8 aidLen, int route);
-    bool removeAidRouting(const UINT8* aid, UINT8 aidLen);
+    bool addAidRouting(const uint8_t* aid, uint8_t aidLen, int route);
+    bool removeAidRouting(const uint8_t* aid, uint8_t aidLen);
     bool commitRouting();
-    int registerT3tIdentifier(UINT8* t3tId, UINT8 t3tIdLen);
+    int registerT3tIdentifier(uint8_t* t3tId, uint8_t t3tIdLen);
     void deregisterT3tIdentifier(int handle);
     void onNfccShutdown();
     int registerJniFunctions (JNIEnv* e);
@@ -48,9 +48,9 @@
     RoutingManager(const RoutingManager&);
     RoutingManager& operator=(const RoutingManager&);
 
-    void handleData (UINT8 technology, const UINT8* data, UINT32 dataLen, tNFA_STATUS status);
-    void notifyActivated (UINT8 technology);
-    void notifyDeactivated (UINT8 technology);
+    void handleData (uint8_t technology, const uint8_t* data, uint32_t dataLen, tNFA_STATUS status);
+    void notifyActivated (uint8_t technology);
+    void notifyDeactivated (uint8_t technology);
 
     // See AidRoutingManager.java for corresponding
     // AID_MATCHING_ constants
@@ -63,14 +63,14 @@
     static const int AID_MATCHING_PREFIX_ONLY = 0x02;
 
     static void nfaEeCallback (tNFA_EE_EVT event, tNFA_EE_CBACK_DATA* eventData);
-    static void stackCallback (UINT8 event, tNFA_CONN_EVT_DATA* eventData);
-    static void nfcFCeCallback (UINT8 event, tNFA_CONN_EVT_DATA* eventData);
+    static void stackCallback (uint8_t event, tNFA_CONN_EVT_DATA* eventData);
+    static void nfcFCeCallback (uint8_t event, tNFA_CONN_EVT_DATA* eventData);
 
     static int com_android_nfc_cardemulation_doGetDefaultRouteDestination (JNIEnv* e);
     static int com_android_nfc_cardemulation_doGetDefaultOffHostRouteDestination (JNIEnv* e);
     static int com_android_nfc_cardemulation_doGetAidMatchingMode (JNIEnv* e);
 
-    std::vector<UINT8> mRxDataBuffer;
+    std::vector<uint8_t> mRxDataBuffer;
 
     // Fields below are final after initialize()
     nfc_jni_native_data* mNativeData;
diff --git a/nci/jni/extns/pn54x/src/log/phNxpLog.c b/nci/jni/extns/pn54x/src/log/phNxpLog.c
index c45a12a..15b1d20 100755
--- a/nci/jni/extns/pn54x/src/log/phNxpLog.c
+++ b/nci/jni/extns/pn54x/src/log/phNxpLog.c
@@ -263,7 +263,7 @@
     ALOGD ("%s: global =%u, Fwdnld =%u, extns =%u, \
                 hal =%u, tml =%u, ncir =%u, \
                 ncix =%u", \
-                __FUNCTION__, gLog_level.global_log_level, gLog_level.dnld_log_level,
+                __func__, gLog_level.global_log_level, gLog_level.dnld_log_level,
                     gLog_level.extns_log_level, gLog_level.hal_log_level, gLog_level.tml_log_level,
                     gLog_level.ncir_log_level, gLog_level.ncix_log_level);
 
diff --git a/nci/jni/extns/pn54x/src/log/phNxpLog.h b/nci/jni/extns/pn54x/src/log/phNxpLog.h
index ec09066..32cbfc1 100755
--- a/nci/jni/extns/pn54x/src/log/phNxpLog.h
+++ b/nci/jni/extns/pn54x/src/log/phNxpLog.h
@@ -91,9 +91,9 @@
 /* ######################################## Defines used for Logging data ######################################### */
 #ifdef NXP_VRBS_REQ
 #define NXPLOG_FUNC_ENTRY(COMP) \
-    LOG_PRI( ANDROID_LOG_VERBOSE, (COMP), "+:%s", (__FUNCTION__))
+    LOG_PRI( ANDROID_LOG_VERBOSE, (COMP), "+:%s", (__func__))
 #define NXPLOG_FUNC_EXIT(COMP) \
-    LOG_PRI(ANDROID_LOG_VERBOSE, (COMP), "-:%s", (__FUNCTION__))
+    LOG_PRI(ANDROID_LOG_VERBOSE, (COMP), "-:%s", (__func__))
 #endif /*NXP_VRBS_REQ*/
 
 /* ################################################################################################################ */
diff --git a/nci/jni/extns/pn54x/src/mifare/phFriNfc_MifareStdMap.c b/nci/jni/extns/pn54x/src/mifare/phFriNfc_MifareStdMap.c
index 66da24b..b70d83a 100755
--- a/nci/jni/extns/pn54x/src/mifare/phFriNfc_MifareStdMap.c
+++ b/nci/jni/extns/pn54x/src/mifare/phFriNfc_MifareStdMap.c
@@ -2678,7 +2678,7 @@
         if((NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_TERMTLV_T) &&
             (NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_NULLTLV_T) &&
             (NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_NDEFTLV_T) &&
-            (FALSE == NdefMap->TLVStruct.NdefTLVFoundFlag))
+            (false == NdefMap->TLVStruct.NdefTLVFoundFlag))
         {
             Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
                                 NFCSTATUS_NO_NDEF_SUPPORT);
diff --git a/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.c b/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.c
index 81318cb..162196a 100755
--- a/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.c
+++ b/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.c
@@ -31,7 +31,7 @@
 #if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
 pthread_mutex_t SharedDataMutex = PTHREAD_MUTEX_INITIALIZER;
 #endif
-UINT8 current_key[6]={0};
+uint8_t current_key[6]={0};
 phNci_mfc_auth_cmd_t       gAuthCmdBuf;
 STATIC NFCSTATUS phNciNfc_SendMfReq(phNciNfc_TransceiveInfo_t tTranscvInfo,
                                     uint8_t *buff, uint16_t *buffSz);
@@ -190,13 +190,13 @@
 NFCSTATUS phNxpExtns_MfcModuleInit(void)
 {
     NFCSTATUS status = NFCSTATUS_FAILED;
-    gphNxpExtns_Context.writecmdFlag = FALSE;
-    gphNxpExtns_Context.RawWriteCallBack = FALSE;
+    gphNxpExtns_Context.writecmdFlag = false;
+    gphNxpExtns_Context.RawWriteCallBack = false;
     gphNxpExtns_Context.CallBackCtxt   = NULL;
     gphNxpExtns_Context.CallBackMifare = NULL;
-    gphNxpExtns_Context.ExtnsConnect = FALSE;
-    gphNxpExtns_Context.ExtnsDeactivate = FALSE;
-    gphNxpExtns_Context.ExtnsCallBack = FALSE;
+    gphNxpExtns_Context.ExtnsConnect = false;
+    gphNxpExtns_Context.ExtnsDeactivate = false;
+    gphNxpExtns_Context.ExtnsCallBack = false;
 
     NdefMap = malloc(sizeof(phFriNfc_NdefMap_t));
     if( NULL == NdefMap )
@@ -318,7 +318,7 @@
 {
     NFCSTATUS status = NFCSTATUS_FAILED;
 
-    EXTNS_SetCallBackFlag(FALSE);
+    EXTNS_SetCallBackFlag(false);
     /* Set Completion Routine for CheckNdef */
     NdefMap->CompletionRoutine[0].CompletionRoutine = Mfc_CheckNdef_Completion_Routine;
 
@@ -579,7 +579,7 @@
 {
     (void)NdefCtxt;
     tNFA_CONN_EVT_DATA conn_evt_data;
-    ALOGE("%s status = 0x%x", __FUNCTION__, status);
+    ALOGE("%s status = 0x%x", __func__, status);
     conn_evt_data.status = status;
     (*gphNxpExtns_Context.p_conn_cback) (NFA_SET_TAG_RO_EVT, &conn_evt_data);
 
@@ -600,11 +600,11 @@
 *******************************************************************************/
 NFCSTATUS Mfc_SetReadOnly(uint8_t *secrtkey, uint8_t len)
 {
-    NXPLOG_EXTNS_D("%s Entering ", __FUNCTION__);
+    NXPLOG_EXTNS_D("%s Entering ", __func__);
     NFCSTATUS status = NFCSTATUS_FAILED;
     uint8_t mif_secrete_key[6] = {0};
     uint8_t id = 0;
-    EXTNS_SetCallBackFlag(FALSE);
+    EXTNS_SetCallBackFlag(false);
     memcpy(mif_secrete_key,secrtkey,len);
     gphNxpExtns_Context.CallBackMifare = phFriNfc_MifareStdMap_Process;
     gphNxpExtns_Context.CallBackCtxt   = NdefMap;
@@ -664,7 +664,7 @@
     uint32_t           *PacketDataLength = NULL;
     phLibNfc_Ndef_EOffset_t Offset;
 
-    EXTNS_SetCallBackFlag(FALSE);
+    EXTNS_SetCallBackFlag(false);
 
     Offset = phLibNfc_Ndef_EBegin;
 
@@ -754,19 +754,19 @@
 {
     NFCSTATUS status = NFCSTATUS_SUCCESS;
 
-    if (gAuthCmdBuf.auth_status == TRUE)
+    if (gAuthCmdBuf.auth_status == true)
     {
-        EXTNS_SetCallBackFlag(FALSE);
+        EXTNS_SetCallBackFlag(false);
         status = nativeNfcExtns_doTransceive(gAuthCmdBuf.pauth_cmd->buffer,
              gAuthCmdBuf.pauth_cmd->length);
         if (status != NFCSTATUS_PENDING)
         {
-            gAuthCmdBuf.auth_sent = FALSE;
+            gAuthCmdBuf.auth_sent = false;
             status = NFCSTATUS_FAILED;
         }
         else
         {
-            gAuthCmdBuf.auth_sent = TRUE;
+            gAuthCmdBuf.auth_sent = true;
             status = NFCSTATUS_SUCCESS;
         }
     }
@@ -774,7 +774,7 @@
     {
         status = NFCSTATUS_NOT_ALLOWED;
     }
-    NXPLOG_EXTNS_D("%s status = 0x%x", __FUNCTION__, status);
+    NXPLOG_EXTNS_D("%s status = 0x%x", __func__, status);
     return status;
 }
 /*******************************************************************************
@@ -802,7 +802,7 @@
         goto Mfc_WrNdefEnd;
     }
 
-    EXTNS_SetCallBackFlag(FALSE);
+    EXTNS_SetCallBackFlag(false);
     gphNxpExtns_Context.CallBackMifare = phFriNfc_MifareStdMap_Process;
     gphNxpExtns_Context.CallBackCtxt   = NdefMap;
 #if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
@@ -939,7 +939,7 @@
 //    static uint8_t   Index;                                               /*commented to eliminate unused variable warning*/
     uint8_t     sak = 0;
 
-    EXTNS_SetCallBackFlag(FALSE);
+    EXTNS_SetCallBackFlag(false);
 
     memcpy(mif_std_key,secretkey,len);
     memcpy(current_key,secretkey,len);
@@ -1003,10 +1003,10 @@
 {
     tNFA_STATUS status;
 
-    EXTNS_SetDeactivateFlag(TRUE);
-    if (NFA_STATUS_OK != (status = NFA_Deactivate (TRUE))) /* deactivate to sleep state */
+    EXTNS_SetDeactivateFlag(true);
+    if (NFA_STATUS_OK != (status = NFA_Deactivate (true))) /* deactivate to sleep state */
     {
-        NXPLOG_EXTNS_E ("%s: deactivate failed, status = %d", __FUNCTION__, status);
+        NXPLOG_EXTNS_E ("%s: deactivate failed, status = %d", __func__, status);
         return NFCSTATUS_FAILED;
     }
 
@@ -1028,11 +1028,11 @@
 {
     tNFA_STATUS status;
 
-    EXTNS_SetConnectFlag(TRUE);
+    EXTNS_SetConnectFlag(true);
     if (NFA_STATUS_OK != (status = NFA_Select (0x01, phNciNfc_e_RfProtocolsMifCProtocol,
                                                      phNciNfc_e_RfInterfacesTagCmd_RF)))
     {
-        NXPLOG_EXTNS_E ("%s: NFA_Select failed, status = %d", __FUNCTION__, status);
+        NXPLOG_EXTNS_E ("%s: NFA_Select failed, status = %d", __func__, status);
     }
 
     return;
@@ -1070,11 +1070,11 @@
     NFCSTATUS status = NFCSTATUS_FAILED;
     uint8_t i = 0x00;
 
-    gphNxpExtns_Context.RawWriteCallBack = FALSE;
+    gphNxpExtns_Context.RawWriteCallBack = false;
     gphNxpExtns_Context.CallBackMifare = NULL;
     gphNxpExtns_Context.CallBackCtxt   = NdefMap;
 
-    EXTNS_SetCallBackFlag(TRUE);
+    EXTNS_SetCallBackFlag(true);
     if( p_data[0] == 0x60 || p_data[0] == 0x61 )
     {
 
@@ -1097,9 +1097,9 @@
     }
     else if( p_data[0] == 0xA0 )
     {
-        EXTNS_SetCallBackFlag(FALSE);
+        EXTNS_SetCallBackFlag(false);
         NdefMap->Cmd.MfCmd = phNfc_eMifareWrite16;
-        gphNxpExtns_Context.RawWriteCallBack = TRUE;
+        gphNxpExtns_Context.RawWriteCallBack = true;
 
         memcpy(NdefMap->SendRecvBuf, &p_data[1], len-1);
         NdefMap->SendLength = len-1;
@@ -1112,9 +1112,9 @@
     else if( (p_data[0] == phNfc_eMifareInc) || (p_data[0] == phNfc_eMifareDec) )
     {
 
-        EXTNS_SetCallBackFlag(FALSE);
+        EXTNS_SetCallBackFlag(false);
         NdefMap->Cmd.MfCmd = p_data[0];
-        gphNxpExtns_Context.RawWriteCallBack = TRUE;
+        gphNxpExtns_Context.RawWriteCallBack = true;
 
         memcpy(NdefMap->SendRecvBuf, &p_data[1], len-1);
         NdefMap->SendLength = len - 1;
@@ -1129,8 +1129,8 @@
         NdefMap->Cmd.MfCmd = p_data[0];
         if (p_data[0] == phNfc_eMifareRestore)
         {
-            EXTNS_SetCallBackFlag(FALSE);
-            gphNxpExtns_Context.RawWriteCallBack = TRUE;
+            EXTNS_SetCallBackFlag(false);
+            gphNxpExtns_Context.RawWriteCallBack = true;
             memcpy(NdefMap->SendRecvBuf, &p_data[1], len -1);
             NdefMap->SendLength = len - 1;
         }
@@ -1187,7 +1187,7 @@
 
     if (status != NFA_STATUS_OK)
     {
-        NXPLOG_EXTNS_E ("%s: fail send; error=%d", __FUNCTION__, status);
+        NXPLOG_EXTNS_E ("%s: fail send; error=%d", __func__, status);
         wStatus = NFCSTATUS_FAILED;
     }
 
@@ -1272,12 +1272,12 @@
                     /* check the status byte */
                     if(PH_NCINFC_STATUS_OK == RspBuffInfo->pBuff[1])
                     {
-                        if (gAuthCmdBuf.auth_sent ==  TRUE)
+                        if (gAuthCmdBuf.auth_sent ==  true)
                         {
                             MfcPresenceCheckResult(NFCSTATUS_SUCCESS);
                             return NFCSTATUS_SUCCESS;
                         }
-                        gAuthCmdBuf.auth_status = TRUE;
+                        gAuthCmdBuf.auth_status = true;
                         status = NFCSTATUS_SUCCESS;
 
                         /* DataLen = TotalRecvdLen - (sizeof(RspId) + sizeof(Status)) */
@@ -1291,9 +1291,9 @@
                     }
                     else
                     {
-                        if (gAuthCmdBuf.auth_sent ==  TRUE)
+                        if (gAuthCmdBuf.auth_sent ==  true)
                         {
-                            gAuthCmdBuf.auth_status = FALSE;
+                            gAuthCmdBuf.auth_status = false;
                             MfcPresenceCheckResult(NFCSTATUS_FAILED);
                             return NFCSTATUS_SUCCESS;
                         }
@@ -1302,7 +1302,7 @@
                             /* Reset the stored auth command buffer */
                             memset(gAuthCmdBuf.pauth_cmd->buffer, 0 , NCI_MAX_DATA_LEN);
                             gAuthCmdBuf.pauth_cmd->length = 0;
-                            gAuthCmdBuf.auth_status = FALSE;
+                            gAuthCmdBuf.auth_status = false;
                         }
                         status = NFCSTATUS_FAILED;
                     }
@@ -1349,10 +1349,10 @@
         wStatus = NFCSTATUS_INVALID_PARAMETER;
     }
 
-    if ( gphNxpExtns_Context.RawWriteCallBack == TRUE )
+    if ( gphNxpExtns_Context.RawWriteCallBack == true )
     {
-        EXTNS_SetCallBackFlag(TRUE);
-        gphNxpExtns_Context.RawWriteCallBack = FALSE;
+        EXTNS_SetCallBackFlag(true);
+        gphNxpExtns_Context.RawWriteCallBack = false;
     }
 
     return wStatus;
@@ -1388,10 +1388,10 @@
         wStatus = NFCSTATUS_INVALID_PARAMETER;
     }
 
-    if ( gphNxpExtns_Context.RawWriteCallBack == TRUE )
+    if ( gphNxpExtns_Context.RawWriteCallBack == true )
     {
-        EXTNS_SetCallBackFlag(TRUE);
-        gphNxpExtns_Context.RawWriteCallBack = FALSE;
+        EXTNS_SetCallBackFlag(true);
+        gphNxpExtns_Context.RawWriteCallBack = false;
     }
 
     return wStatus;
@@ -1419,13 +1419,13 @@
     RspBuff.pBuff = buff;
     RspBuff.wLen  = buffSz;
     status = phNciNfc_RecvMfResp(&RspBuff, status);
-    if (TRUE == gAuthCmdBuf.auth_sent)
+    if (true == gAuthCmdBuf.auth_sent)
     {
-        ALOGD("%s Mfc Check Presence in progress", __FUNCTION__);
-        gAuthCmdBuf.auth_sent = FALSE;
+        ALOGD("%s Mfc Check Presence in progress", __func__);
+        gAuthCmdBuf.auth_sent = false;
         return status;
     }
-    if( TRUE == gphNxpExtns_Context.writecmdFlag && (NFCSTATUS_SUCCESS == status ))
+    if(true == gphNxpExtns_Context.writecmdFlag && (NFCSTATUS_SUCCESS == status ))
     {
         pcmd_buff = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE);
         if( NULL == pcmd_buff )
@@ -1433,7 +1433,7 @@
             return NFCSTATUS_FAILED;
         }
         buffSize = MAX_BUFF_SIZE;
-        gphNxpExtns_Context.writecmdFlag = FALSE;
+        gphNxpExtns_Context.writecmdFlag = false;
         phLibNfc_SendWrt16CmdPayload(NdefMap->pTransceiveInfo, &tNciTranscvInfo);
         status = phNciNfc_SendMfReq(tNciTranscvInfo, pcmd_buff, &buffSize);
         if ( NFCSTATUS_PENDING != status )
@@ -1450,7 +1450,7 @@
             pcmd_buff = NULL;
         }
     }
-    else if( TRUE == gphNxpExtns_Context.incrdecflag && (NFCSTATUS_SUCCESS == status ))
+    else if(true == gphNxpExtns_Context.incrdecflag && (NFCSTATUS_SUCCESS == status ))
     {
         pcmd_buff = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE);
         if( NULL == pcmd_buff )
@@ -1458,7 +1458,7 @@
             return NFCSTATUS_FAILED;
         }
         buffSize = MAX_BUFF_SIZE;
-        gphNxpExtns_Context.incrdecflag = FALSE;
+        gphNxpExtns_Context.incrdecflag = false;
         phLibNfc_SendIncDecCmdPayload(NdefMap->pTransceiveInfo, &tNciTranscvInfo);
         status = phNciNfc_SendMfReq(tNciTranscvInfo, pcmd_buff, &buffSize);
         if ( NFCSTATUS_PENDING != status )
@@ -1469,7 +1469,7 @@
         {
             status = NFCSTATUS_SUCCESS;
         }
-        gphNxpExtns_Context.incrdecstatusflag = TRUE;
+        gphNxpExtns_Context.incrdecstatusflag = true;
         if( pcmd_buff != NULL )
         {
             free(pcmd_buff);
@@ -1481,9 +1481,9 @@
     {
         if( gphNxpExtns_Context.CallBackMifare != NULL )
         {
-            if( (gphNxpExtns_Context.incrdecstatusflag == TRUE) && status == 0xB2 )
+            if( (gphNxpExtns_Context.incrdecstatusflag == true) && status == 0xB2 )
             {
-                gphNxpExtns_Context.incrdecstatusflag = FALSE;
+                gphNxpExtns_Context.incrdecstatusflag = false;
                 status = NFCSTATUS_SUCCESS;
             }
             gphNxpExtns_Context.CallBackMifare(gphNxpExtns_Context.CallBackCtxt, status);
@@ -2087,7 +2087,7 @@
         pTransceiveInfo->sSendData.length = length;
         pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
 
-        gphNxpExtns_Context.writecmdFlag = TRUE;
+        gphNxpExtns_Context.writecmdFlag = true;
 
         status = phLibNfc_SendWrt16Cmd(pTransceiveInfo, &tNciTranscvInfo);
     }
@@ -2099,7 +2099,7 @@
         pTransceiveInfo->sSendData.length = length;
         pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
 
-        gphNxpExtns_Context.incrdecflag = TRUE;
+        gphNxpExtns_Context.incrdecflag = true;
 
         status = phLibNfc_SendIncDecCmd(pTransceiveInfo, &tNciTranscvInfo, Cmd.MfCmd);
 
@@ -2112,7 +2112,7 @@
         pTransceiveInfo->sSendData.length = length + sizeof(restore_payload);
         pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
 
-        gphNxpExtns_Context.incrdecflag = TRUE;
+        gphNxpExtns_Context.incrdecflag = true;
 
         status = phLibNfc_SendIncDecCmd(pTransceiveInfo, &tNciTranscvInfo, Cmd.MfCmd);
 
diff --git a/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.h b/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.h
index 0ed0fe9..3af15b7 100755
--- a/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.h
+++ b/nci/jni/extns/pn54x/src/mifare/phNxpExtns_MifareStd.h
@@ -25,7 +25,7 @@
 #include <semaphore.h>
 #include <pthread.h>
 
-extern UINT8 current_key[];
+extern uint8_t current_key[];
 /* Enable this macro to set key configuration for mifare classic Tag */
 #define PHLIBNFC_NXPETENSION_CONFIGURE_MFKEYS 1
 
diff --git a/nci/jni/extns/pn54x/src/phNxpExtns.c b/nci/jni/extns/pn54x/src/phNxpExtns.c
index 9094e24..1c2afdc 100755
--- a/nci/jni/extns/pn54x/src/phNxpExtns.c
+++ b/nci/jni/extns/pn54x/src/phNxpExtns.c
@@ -230,7 +230,7 @@
     gAuthCmdBuf.status = NFCSTATUS_FAILED;
     if (sem_init (&gAuthCmdBuf.semPresenceCheck, 0, 0) == -1)
     {
-        ALOGE ("%s: semaphore creation failed (errno=%d)", __FUNCTION__, errno);
+        ALOGE ("%s: semaphore creation failed (errno=%d)", __func__, errno);
         return NFCSTATUS_FAILED;
     }
 
@@ -629,14 +629,14 @@
 
     if (sem_timedwait (&gAuthCmdBuf.semPresenceCheck, &ts))
     {
-        ALOGE ("%s: failed to wait (errno=%d)", __FUNCTION__, errno);
+        ALOGE ("%s: failed to wait (errno=%d)", __func__, errno);
         sem_destroy (&gAuthCmdBuf.semPresenceCheck);
-        gAuthCmdBuf.auth_sent = FALSE;
+        gAuthCmdBuf.auth_sent = false;
         return NFCSTATUS_FAILED;
     }
     if (sem_destroy (&gAuthCmdBuf.semPresenceCheck))
     {
-        ALOGE ("%s: Failed to destroy check Presence semaphore (errno=%d)", __FUNCTION__, errno);
+        ALOGE ("%s: Failed to destroy check Presence semaphore (errno=%d)", __func__, errno);
     }
     return gAuthCmdBuf.status;
 }
@@ -644,12 +644,12 @@
 void MfcPresenceCheckResult (NFCSTATUS status)
 {
     gAuthCmdBuf.status = status;
-    EXTNS_SetCallBackFlag (TRUE);
+    EXTNS_SetCallBackFlag (true);
     sem_post (&gAuthCmdBuf.semPresenceCheck);
 }
 void MfcResetPresenceCheckStatus (void)
 {
-    gAuthCmdBuf.auth_sent = FALSE;
+    gAuthCmdBuf.auth_sent = false;
 }
 /*******************************************************************************
 **