diff --git a/halimpl/hal/phNxpUciHal.cc b/halimpl/hal/phNxpUciHal.cc
index cd5da12..34c1e9d 100644
--- a/halimpl/hal/phNxpUciHal.cc
+++ b/halimpl/hal/phNxpUciHal.cc
@@ -63,24 +63,18 @@
  * RX packet handler
  ******************************************************************************/
 struct phNxpUciHal_RxHandler {
+  phNxpUciHal_RxHandler(uint8_t mt, uint8_t gid, uint8_t oid,
+    bool run_once, RxHandlerCallback callback) :
+      mt(mt), gid(gid), oid(oid),
+      run_once(run_once),
+      callback(callback) { }
+
   // mt, gid, oid: packet type
   uint8_t mt;
   uint8_t gid;
   uint8_t oid;
-
-  // skip_reporting: not reports the packet to upper layer if it's true
-  bool skip_reporting;
   bool run_once;
-
-  std::function<void(size_t packet_len, const uint8_t *packet)> callback;
-
-  phNxpUciHal_RxHandler(uint8_t mt, uint8_t gid, uint8_t oid,
-    bool skip_reporting, bool run_once,
-    std::function<void(size_t packet_len, const uint8_t *packet)> callback) :
-      mt(mt), gid(gid), oid(oid),
-      skip_reporting(skip_reporting),
-      run_once(run_once),
-      callback(callback) { }
+  RxHandlerCallback callback;
 };
 
 static std::list<std::shared_ptr<phNxpUciHal_RxHandler>> rx_handlers;
@@ -88,11 +82,11 @@
 
 std::shared_ptr<phNxpUciHal_RxHandler> phNxpUciHal_rx_handler_add(
   uint8_t mt, uint8_t gid, uint8_t oid,
-  bool skip_reporting, bool run_once,
-  std::function<void(size_t packet_len, const uint8_t *packet)> callback)
+  bool run_once,
+  RxHandlerCallback callback)
 {
-  auto handler = std::make_shared<phNxpUciHal_RxHandler>(mt, gid, oid,
-    skip_reporting, run_once, callback);
+  auto handler = std::make_shared<phNxpUciHal_RxHandler>(
+    mt, gid, oid, run_once, callback);
   std::lock_guard<std::mutex> guard(rx_handlers_lock);
   rx_handlers.push_back(handler);
   return handler;
@@ -116,8 +110,7 @@
 
   for (auto handler : rx_handlers) {
     if (mt == handler->mt && gid == handler->gid && oid == handler->oid) {
-      handler->callback(packet_len, packet);
-      if (handler->skip_reporting) {
+      if (handler->callback(packet_len, packet)) {
         skip_packet = true;
       }
     }
@@ -798,14 +791,14 @@
 
 static bool cacheDevInfoRsp()
 {
-  auto dev_info_cb = [](size_t packet_len, const uint8_t *packet) mutable {
+  auto dev_info_cb = [](size_t packet_len, const uint8_t *packet) mutable -> bool {
     if (packet_len < 5 || packet[UCI_RESPONSE_STATUS_OFFSET] != UWBSTATUS_SUCCESS) {
       NXPLOG_UCIHAL_E("Failed to get valid CORE_DEVICE_INFO_RSP");
-      return;
+      return true;
     }
     if (packet_len > sizeof(nxpucihal_ctrl.dev_info_resp)) {
       NXPLOG_UCIHAL_E("FIXME: CORE_DEVICE_INFO_RSP buffer overflow!");
-      return;
+      return true;
     }
 
     // FIRA UCIv2.0 packet size = 14
@@ -815,7 +808,7 @@
 
     if (packet_len < firaDevInfoRspSize) {
       NXPLOG_UCIHAL_E("DEVICE_INFO_RSP packet size mismatched.");
-      return;
+      return true;
     }
 
     const uint8_t vendorSpecificLen = packet[firaDevInfoVendorLenOffset];
@@ -844,10 +837,11 @@
     memcpy(nxpucihal_ctrl.dev_info_resp, packet, packet_len);
     nxpucihal_ctrl.isDevInfoCached = true;
     NXPLOG_UCIHAL_D("Device Info cached.");
+    return true;
   };
 
   nxpucihal_ctrl.isDevInfoCached = false;
-  UciHalRxHandler devInfoRspHandler(UCI_MT_RSP, UCI_GID_CORE, UCI_MSG_CORE_DEVICE_INFO, true, dev_info_cb);
+  UciHalRxHandler devInfoRspHandler(UCI_MT_RSP, UCI_GID_CORE, UCI_MSG_CORE_DEVICE_INFO, dev_info_cb);
 
   const uint8_t CoreGetDevInfoCmd[] = {(UCI_MT_CMD << UCI_MT_SHIFT) | UCI_GID_CORE, UCI_MSG_CORE_DEVICE_INFO, 0, 0};
   tHAL_UWB_STATUS status = phNxpUciHal_send_ext_cmd(sizeof(CoreGetDevInfoCmd), CoreGetDevInfoCmd);
@@ -879,16 +873,16 @@
   // Device Status Notification
   UciHalSemaphore devStatusNtfWait;
   uint8_t dev_status = UWB_DEVICE_ERROR;
-  auto dev_status_ntf_cb = [&dev_status,
-                            &devStatusNtfWait](size_t packet_len,
-                                               const uint8_t *packet) mutable {
+  auto dev_status_ntf_cb = [&dev_status, &devStatusNtfWait]
+      (size_t packet_len, const uint8_t *packet) mutable -> bool {
     if (packet_len >= 5) {
       dev_status = packet[UCI_RESPONSE_STATUS_OFFSET];
       devStatusNtfWait.post();
     }
+    return true;
   };
   UciHalRxHandler devStatusNtfHandler(UCI_MT_NTF, UCI_GID_CORE, UCI_MSG_CORE_DEVICE_STATUS_NTF,
-                                      true, dev_status_ntf_cb);
+                                      dev_status_ntf_cb);
 
   // FW download and enter UCI operating mode
   status = nxpucihal_ctrl.uwb_chip->chip_init();
diff --git a/halimpl/hal/phNxpUciHal.h b/halimpl/hal/phNxpUciHal.h
index c7a08d2..28cc97e 100644
--- a/halimpl/hal/phNxpUciHal.h
+++ b/halimpl/hal/phNxpUciHal.h
@@ -308,22 +308,28 @@
 void phNxpUciHal_send_dev_error_status_ntf();
 bool phNxpUciHal_parse(uint16_t data_len, const uint8_t *p_data);
 
+// RX packet handler
+// handler should returns true if the packet is handled and
+// shouldn't report it to the upper layer.
+
+using RxHandlerCallback = std::function<bool(size_t packet_len, const uint8_t *packet)>;
+
 std::shared_ptr<phNxpUciHal_RxHandler> phNxpUciHal_rx_handler_add(
   uint8_t mt, uint8_t gid, uint8_t oid,
-  bool skip_reporting, bool run_once,
-  std::function<void(size_t packet_len, const uint8_t *packet)> callback);
+  bool run_once,
+  RxHandlerCallback callback);
 void phNxpUciHal_rx_handler_del(std::shared_ptr<phNxpUciHal_RxHandler> handler);
 
-// Helper class for rx handler with once=false
+// Helper class for rx handler with run_once=false
 // auto-unregistered from destructor
+
 class UciHalRxHandler {
 public:
   UciHalRxHandler() {
   }
   UciHalRxHandler(uint8_t mt, uint8_t gid, uint8_t oid,
-                 bool skip_reporting,
-                 std::function<void(size_t packet_len, const uint8_t *packet)> callback) {
-    handler_ = phNxpUciHal_rx_handler_add(mt, gid, oid, skip_reporting, false, callback);
+                  RxHandlerCallback callback) {
+    handler_ = phNxpUciHal_rx_handler_add(mt, gid, oid, false, callback);
   }
   UciHalRxHandler& operator=(UciHalRxHandler &&handler) {
     handler_ = std::move(handler.handler_);
diff --git a/halimpl/hal/sessionTrack.cc b/halimpl/hal/sessionTrack.cc
index be63067..56d2697 100644
--- a/halimpl/hal/sessionTrack.cc
+++ b/halimpl/hal/sessionTrack.cc
@@ -153,7 +153,7 @@
     // register SESSION_STATUS_NTF rx handler
     rx_handler_session_status_ntf_ = phNxpUciHal_rx_handler_add(
       UCI_MT_NTF, UCI_GID_SESSION_MANAGE, UCI_MSG_SESSION_STATUS_NTF,
-      false, false,
+      false,
       std::bind(&SessionTrack::OnSessionStatusNtf, this, std::placeholders::_1, std::placeholders::_2));
   }
 
@@ -179,15 +179,15 @@
 
     // Check SESSION_INIT_RSP for SessionID - Handle matching
     auto session_init_rsp_cb =
-      [this, session_id, session_type](size_t packet_len, const uint8_t *packet)
+      [this, session_id, session_type](size_t packet_len, const uint8_t *packet) -> bool
     {
       if (packet_len != UCI_MSG_SESSION_STATE_INIT_RSP_LEN )
-        return;
+        return false;
 
       uint8_t status = packet[UCI_MSG_SESSION_STATE_INIT_RSP_STATUS_OFFSET];
       uint32_t handle = le_bytes_to_cpu<uint32_t>(&packet[UCI_MSG_SESSION_STATE_INIT_RSP_HANDLE_OFFSET]);
       if (status != UWBSTATUS_SUCCESS)
-        return;
+        return false;
 
       bool was_idle;
       {
@@ -203,12 +203,14 @@
         auto msg = std::make_shared<SessionTrackMsg>(SessionTrackWorkType::ACTIVATE, false);
         QueueSessionTrackWork(msg);
       }
+
+      return false;
     };
 
     // XXX: This rx handler can be called multiple times on
     // UCI_STATUS_COMMAND_RETRY(0xA) from SESSION_INIT_CMD
     phNxpUciHal_rx_handler_add(UCI_MT_RSP, UCI_GID_SESSION_MANAGE,
-      UCI_MSG_SESSION_STATE_INIT, false, true, session_init_rsp_cb);
+      UCI_MSG_SESSION_STATE_INIT, true, session_init_rsp_cb);
   }
 
   // Called by upper-layer's SetAppConfig command handler
@@ -342,20 +344,21 @@
     phNxpUciHal_init_cb_data(&urskDeleteNtfWait, NULL);
 
     phNxpUciHal_rx_handler_add(UCI_MT_RSP, UCI_GID_PROPRIETARY_0X0F,
-      UCI_MSG_URSK_DELETE, true, true,
-      [](size_t packet_len, const uint8_t *packet) {
+      UCI_MSG_URSK_DELETE, true,
+      [](size_t packet_len, const uint8_t *packet) -> bool {
         if (packet_len < 5)
-          return;
+          return true;
         if (packet[4] != UWBSTATUS_SUCCESS) {
           NXPLOG_UCIHAL_E("SessionTrack: URSR_DELETE failed, rsp status=0x%x", packet[4]);
         }
+        return true;
       }
     );
     phNxpUciHal_rx_handler_add(UCI_MT_NTF, UCI_GID_PROPRIETARY_0X0F,
-      UCI_MSG_URSK_DELETE, true, true,
-      [&urskDeleteNtfWait](size_t packet_len, const uint8_t *packet) {
+      UCI_MSG_URSK_DELETE, true,
+      [&urskDeleteNtfWait](size_t packet_len, const uint8_t *packet) -> bool {
         if (packet_len < 6)
-          return;
+          return true;
         uint8_t status = packet[4];
         uint8_t nr = packet[5];
 
@@ -384,6 +387,7 @@
           }
         }
         SEM_POST(&urskDeleteNtfWait);
+        return true;
       }
     );
 
@@ -418,29 +422,30 @@
     bool result = false;
 
     phNxpUciHal_rx_handler_add(UCI_MT_RSP, UCI_GID_SESSION_MANAGE,
-      UCI_MSG_SESSION_GET_APP_CONFIG, true, true,
-      [&val, &result, tag](size_t packet_len, const uint8_t *packet) {
+      UCI_MSG_SESSION_GET_APP_CONFIG, true,
+      [&val, &result, tag](size_t packet_len, const uint8_t *packet) -> bool {
         if (packet_len != 12)
-          return;
+          return true;
 
         if (packet[4] != UWBSTATUS_SUCCESS) {
           NXPLOG_UCIHAL_E("SessionTrack: GetAppConfig failed, status=0x%02x", packet[4]);
-          return;
+          return true;
         }
         if (packet[5] != 1) {
           NXPLOG_UCIHAL_E("SessionTrack: GetAppConfig failed, nr=%u", packet[5]);
-          return;
+          return true;
         }
         if (packet[6] != tag) {
           NXPLOG_UCIHAL_E("SessionTrack: GetAppConfig failed, tag=0x%02x, expected=0x%02x", packet[6], tag);
-          return;
+          return true;
         }
         if (packet[7] != 4) {
           NXPLOG_UCIHAL_E("SessionTrack: GetAppConfig failed, len=%u", packet[7]);
-          return;
+          return true;
         }
         val = le_bytes_to_cpu<uint32_t>(&packet[8]);
         result = true;
+        return true;
       }
     );
 
@@ -512,10 +517,10 @@
   }
 
   // UCI_MSG_SESSION_STATUS_NTF rx handler
-  void OnSessionStatusNtf(size_t packet_len, const uint8_t* packet) {
+  bool OnSessionStatusNtf(size_t packet_len, const uint8_t* packet) {
     if (packet_len != UCI_MSG_SESSION_STATUS_NTF_LENGTH) {
       NXPLOG_UCIHAL_E("SessionTrack: SESSION_STATUS_NTF packet parse error");
-      return;
+      return false;
     }
 
     uint32_t session_handle = le_bytes_to_cpu<uint32_t>(&packet[UCI_MSG_SESSION_STATUS_NTF_HANDLE_OFFSET]);
@@ -553,6 +558,8 @@
       auto msg = std::make_shared<SessionTrackMsg>(SessionTrackWorkType::IDLE, false);
       QueueSessionTrackWork(msg);
     }
+
+    return false;
   }
 
   static void IdleTimerCallback(uint32_t TimerId, void* pContext) {
diff --git a/halimpl/hal/sr1xx/NxpUwbChipSr1xx.cc b/halimpl/hal/sr1xx/NxpUwbChipSr1xx.cc
index d24a32f..2183d97 100644
--- a/halimpl/hal/sr1xx/NxpUwbChipSr1xx.cc
+++ b/halimpl/hal/sr1xx/NxpUwbChipSr1xx.cc
@@ -47,7 +47,7 @@
   // NXP_READ_CALIB_DATA_NTF
   bool received = false;
   auto read_calib_ntf_cb =
-  [&] (size_t packet_len, const uint8_t *packet) mutable
+  [&] (size_t packet_len, const uint8_t *packet) mutable -> bool
   {
     // READ_CALIB_DATA_NTF: status(1), length-of-payload(1), payload(N)
     const uint8_t plen = packet[3]; // payload-length
@@ -65,10 +65,11 @@
       received = true;
       SEM_POST(&calib_data_ntf_wait);
     }
+    return true;
   };
   auto handler = phNxpUciHal_rx_handler_add(
       UCI_MT_NTF, UCI_GID_PROPRIETARY_0X0A, UCI_MSG_READ_CALIB_DATA,
-      true, true, read_calib_ntf_cb);
+      true, read_calib_ntf_cb);
 
 
   // READ_CALIB_DATA_CMD
@@ -170,7 +171,7 @@
   phNxpUciHal_init_cb_data(&binding_ntf_wait, NULL);
 
   auto binding_ntf_cb =
-    [&](size_t packet_len, const uint8_t *packet) mutable
+    [&](size_t packet_len, const uint8_t *packet) mutable -> bool
   {
       if (packet_len == UCI_MSG_UWB_ESE_BINDING_LEN) {
         uint8_t status = packet[UCI_RESPONSE_STATUS_OFFSET];
@@ -185,10 +186,11 @@
       } else {
         NXPLOG_UCIHAL_E("UWB_ESE_BINDING_NTF: packet length mismatched %zu", packet_len);
       }
+      return true;
   };
   auto handler = phNxpUciHal_rx_handler_add(
       UCI_MT_NTF, UCI_GID_PROPRIETARY_0X0F, UCI_MSG_UWB_ESE_BINDING,
-      true, true, binding_ntf_cb);
+      true, binding_ntf_cb);
 
   // UWB_ESE_BINDING_CMD
   uint8_t buffer[] = {0x2F, 0x31, 0x00, 0x00};
@@ -229,16 +231,17 @@
   uint8_t binding_status_got = UWB_DEVICE_UNKNOWN;
   phNxpUciHal_Sem_t binding_check_ntf_wait;
   phNxpUciHal_init_cb_data(&binding_check_ntf_wait, NULL);
-  auto binding_check_ntf_cb = [&](size_t packet_len, const uint8_t *packet) mutable {
+  auto binding_check_ntf_cb = [&](size_t packet_len, const uint8_t *packet) mutable -> bool {
     if (packet_len >= UCI_RESPONSE_STATUS_OFFSET) {
       binding_status_got = packet[UCI_RESPONSE_STATUS_OFFSET];
       NXPLOG_UCIHAL_D("Received UWB_ESE_BINDING_CHECK_NTF, binding_status=0x%x", binding_status_got);
       SEM_POST(&binding_check_ntf_wait);
     }
+    return true;
   };
   auto handler = phNxpUciHal_rx_handler_add(
       UCI_MT_NTF, UCI_GID_PROPRIETARY_0X0F, UCI_MSG_UWB_ESE_BINDING_CHECK,
-      true, true, binding_check_ntf_cb);
+      true, binding_check_ntf_cb);
 
   // UWB_ESE_BINDING_CHECK_CMD
   uint8_t lock_cmd[] = {0x2F, 0x32, 0x00, 0x00};
@@ -334,9 +337,9 @@
 
 private:
   tHAL_UWB_STATUS check_binding();
-  void onDeviceStatusNtf(size_t packet_len, const uint8_t* packet);
-  void onGenericErrorNtf(size_t packet_len, const uint8_t* packet);
-  void onBindingStatusNtf(size_t packet_len, const uint8_t* packet);
+  bool onDeviceStatusNtf(size_t packet_len, const uint8_t* packet);
+  bool onGenericErrorNtf(size_t packet_len, const uint8_t* packet);
+  bool onBindingStatusNtf(size_t packet_len, const uint8_t* packet);
 
 private:
   UciHalRxHandler deviceStatusNtfHandler_;
@@ -355,7 +358,7 @@
 {
 }
 
-void NxpUwbChipSr1xx::onDeviceStatusNtf(size_t packet_len, const uint8_t* packet)
+bool NxpUwbChipSr1xx::onDeviceStatusNtf(size_t packet_len, const uint8_t* packet)
 {
   if(packet_len > UCI_RESPONSE_STATUS_OFFSET) {
     uint8_t status = packet[UCI_RESPONSE_STATUS_OFFSET];
@@ -363,26 +366,29 @@
       sr1xx_clear_device_error();
     }
   }
+  return false;
 }
 
-void NxpUwbChipSr1xx::onGenericErrorNtf(size_t packet_len, const uint8_t* packet)
+bool NxpUwbChipSr1xx::onGenericErrorNtf(size_t packet_len, const uint8_t* packet)
 {
   if(packet_len > UCI_RESPONSE_STATUS_OFFSET) {
     uint8_t status = packet[UCI_RESPONSE_STATUS_OFFSET];
     if ( status == UCI_STATUS_THERMAL_RUNAWAY || status == UCI_STATUS_LOW_VBAT) {
-      nxpucihal_ctrl.isSkipPacket = 1;
       sr1xx_handle_device_error();
+      return true;
     }
   }
+  return false;
 }
 
-void NxpUwbChipSr1xx::onBindingStatusNtf(size_t packet_len, const uint8_t* packet)
+bool NxpUwbChipSr1xx::onBindingStatusNtf(size_t packet_len, const uint8_t* packet)
 {
   if (packet_len > UCI_RESPONSE_STATUS_OFFSET) {
     bindingStatus_ = packet[UCI_RESPONSE_STATUS_OFFSET];
     NXPLOG_UCIHAL_D("BINDING_STATUS_NTF: 0x%x", bindingStatus_);
     bindingStatusNtfWait_.post(UWBSTATUS_SUCCESS);
   }
+  return true;
 }
 
 tHAL_UWB_STATUS NxpUwbChipSr1xx::check_binding()
@@ -492,19 +498,19 @@
 
   // register device status ntf handler
   deviceStatusNtfHandler_ = UciHalRxHandler(
-      UCI_MT_NTF, UCI_GID_CORE, UCI_MSG_CORE_DEVICE_STATUS_NTF, false,
+      UCI_MT_NTF, UCI_GID_CORE, UCI_MSG_CORE_DEVICE_STATUS_NTF,
       std::bind(&NxpUwbChipSr1xx::onDeviceStatusNtf, this, std::placeholders::_1, std::placeholders::_2)
   );
 
   // register device error ntf handler
   genericErrorNtfHandler_ = UciHalRxHandler(
-    UCI_MT_NTF, UCI_GID_CORE, UCI_MSG_CORE_GENERIC_ERROR_NTF, false,
+    UCI_MT_NTF, UCI_GID_CORE, UCI_MSG_CORE_GENERIC_ERROR_NTF,
     std::bind(&NxpUwbChipSr1xx::onGenericErrorNtf, this, std::placeholders::_1, std::placeholders::_2)
   );
 
   // register binding status ntf handler
   bindingStatusNtfHandler_ = UciHalRxHandler(
-      UCI_MT_NTF, UCI_GID_PROPRIETARY, UCI_MSG_BINDING_STATUS_NTF, true,
+      UCI_MT_NTF, UCI_GID_PROPRIETARY, UCI_MSG_BINDING_STATUS_NTF,
       std::bind(&NxpUwbChipSr1xx::onBindingStatusNtf, this, std::placeholders::_1, std::placeholders::_2)
   );
 
diff --git a/halimpl/hal/sr200/NxpUwbChipSr200.cc b/halimpl/hal/sr200/NxpUwbChipSr200.cc
index 2b28127..a1ba4cb 100644
--- a/halimpl/hal/sr200/NxpUwbChipSr200.cc
+++ b/halimpl/hal/sr200/NxpUwbChipSr200.cc
@@ -26,7 +26,7 @@
   tHAL_UWB_STATUS apply_calibration(extcal_param_id_t id, const uint8_t ch, const uint8_t *data, size_t data_len);
   tHAL_UWB_STATUS get_supported_channels(const uint8_t **cal_channels, uint8_t *nr);
 private:
-  void on_binding_status_ntf(size_t packet_len, const uint8_t* packet);
+  bool on_binding_status_ntf(size_t packet_len, const uint8_t* packet);
 
   tHAL_UWB_STATUS check_binding_done();
 
@@ -44,13 +44,14 @@
 {
 }
 
-void NxpUwbChipSr200::on_binding_status_ntf(size_t packet_len, const uint8_t* packet)
+bool NxpUwbChipSr200::on_binding_status_ntf(size_t packet_len, const uint8_t* packet)
 {
   if (packet_len >= UCI_RESPONSE_STATUS_OFFSET) {
     bindingStatus_ = packet[UCI_RESPONSE_STATUS_OFFSET];
     NXPLOG_UCIHAL_D("BINDING_STATUS_NTF: 0x%x", bindingStatus_);
     bindingStatusNtfWait_.post(UWBSTATUS_SUCCESS);
   }
+  return true;
 }
 
 tHAL_UWB_STATUS NxpUwbChipSr200::check_binding_done()
@@ -119,7 +120,6 @@
   // register binding status ntf handler
   bindingStatusNtfHandler_ = UciHalRxHandler(
       UCI_MT_NTF, UCI_GID_PROPRIETARY, UCI_MSG_BINDING_STATUS_NTF,
-      true,
       std::bind(&NxpUwbChipSr200::on_binding_status_ntf, this, std::placeholders::_1, std::placeholders::_2));
 
   return status;