diff --git a/openair2/COMMON/f1ap_messages_types.h b/openair2/COMMON/f1ap_messages_types.h
index 788ddd48cd..366a7c6e95 100644
--- a/openair2/COMMON/f1ap_messages_types.h
+++ b/openair2/COMMON/f1ap_messages_types.h
@@ -1031,6 +1031,22 @@ typedef struct f1ap_srs_type_s {
   f1ap_srs_type_u choice;
 } f1ap_srs_type_t;
 
+typedef union f1ap_abort_transmission_c {
+  uint8_t srs_resource_set_id;
+  bool release_all;
+} f1ap_abort_transmission_u;
+
+typedef enum f1ap_abort_transmission_e {
+  F1AP_ABORT_TRANSMISSION_PR_NOTHING,
+  F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID,
+  F1AP_ABORT_TRANSMISSION_PR_RELEASEALL
+} f1ap_abort_transmission_pr;
+
+typedef struct f1ap_abort_transmission_s {
+  f1ap_abort_transmission_pr present;
+  f1ap_abort_transmission_u choice;
+} f1ap_abort_transmission_t;
+
 typedef struct f1ap_positioning_information_req_s {
   // IE 9.3.1.4 (mandatory)
   uint32_t gNB_CU_ue_id;
@@ -1085,4 +1101,13 @@ typedef struct f1ap_positioning_activation_failure_s {
   long cause_value;
 } f1ap_positioning_activation_failure_t;
 
+typedef struct f1ap_positioning_deactivation_s {
+  // IE 9.3.1.4 (mandatory)
+  uint32_t gNB_CU_ue_id;
+  // IE 9.3.1.5 (mandatory)
+  uint32_t gNB_DU_ue_id;
+  // (mandatory)
+  f1ap_abort_transmission_t abort_transmission;
+} f1ap_positioning_deactivation_t;
+
 #endif /* F1AP_MESSAGES_TYPES_H_ */
diff --git a/openair2/F1AP/lib/f1ap_positioning.c b/openair2/F1AP/lib/f1ap_positioning.c
index 68d942237c..c664674240 100644
--- a/openair2/F1AP/lib/f1ap_positioning.c
+++ b/openair2/F1AP/lib/f1ap_positioning.c
@@ -2032,6 +2032,48 @@ static bool decode_f1ap_srstype(const F1AP_SRSType_t *srs_type, f1ap_srs_type_t
   return true;
 }
 
+static F1AP_AbortTransmission_t encode_f1ap_abort_transmission(const f1ap_abort_transmission_t *abort_tx)
+{
+  F1AP_AbortTransmission_t f1_abort_tx = {0};
+  switch (abort_tx->present) {
+    case F1AP_ABORT_TRANSMISSION_PR_NOTHING:
+      f1_abort_tx.present = F1AP_AbortTransmission_PR_NOTHING;
+      break;
+    case F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID:
+      f1_abort_tx.present = F1AP_AbortTransmission_PR_sRSResourceSetID;
+      f1_abort_tx.choice.sRSResourceSetID = abort_tx->choice.srs_resource_set_id;
+      break;
+    case F1AP_ABORT_TRANSMISSION_PR_RELEASEALL:
+      f1_abort_tx.present = F1AP_AbortTransmission_PR_releaseALL;
+      break;
+    default:
+      AssertFatal(false, "unknown Abort Transmission %d\n", abort_tx->present);
+      break;
+  }
+  return f1_abort_tx;
+}
+
+static bool decode_f1ap_abort_transmission(const F1AP_AbortTransmission_t *in, f1ap_abort_transmission_t *out)
+{
+  switch (in->present) {
+    case F1AP_AbortTransmission_PR_NOTHING:
+      out->present = F1AP_ABORT_TRANSMISSION_PR_NOTHING;
+      break;
+    case F1AP_AbortTransmission_PR_sRSResourceSetID:
+      out->present = F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID;
+      out->choice.srs_resource_set_id = in->choice.sRSResourceSetID;
+      break;
+    case F1AP_AbortTransmission_PR_releaseALL:
+      out->present = F1AP_ABORT_TRANSMISSION_PR_RELEASEALL;
+      out->choice.release_all = true;
+      break;
+    default:
+      AssertError(false, return false, "received illegal Abort Transmission %d\n", in->present);
+      break;
+  }
+  return true;
+}
+
 /**
  * @brief Encode F1 positioning information request to ASN.1
  */
@@ -2848,3 +2890,146 @@ void free_positioning_activation_failure(f1ap_positioning_activation_failure_t *
 {
   // nothing to free
 }
+
+/**
+ * @brief Encode F1 positioning deactivation to ASN.1
+ */
+F1AP_F1AP_PDU_t *encode_positioning_deactivation(const f1ap_positioning_deactivation_t *msg)
+{
+  F1AP_F1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu));
+
+  /* Message Type */
+  pdu->present = F1AP_F1AP_PDU_PR_initiatingMessage;
+  asn1cCalloc(pdu->choice.initiatingMessage, tmp);
+  tmp->procedureCode = F1AP_ProcedureCode_id_PositioningDeactivation;
+  tmp->criticality = F1AP_Criticality_ignore;
+  tmp->value.present = F1AP_InitiatingMessage__value_PR_PositioningDeactivation;
+  F1AP_PositioningDeactivation_t *out = &tmp->value.choice.PositioningDeactivation;
+
+  /* mandatory : GNB_CU_UE_F1AP_ID */
+  asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningDeactivationIEs_t, ie1);
+  ie1->id = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
+  ie1->criticality = F1AP_Criticality_reject;
+  ie1->value.present = F1AP_PositioningDeactivationIEs__value_PR_GNB_CU_UE_F1AP_ID;
+  ie1->value.choice.GNB_CU_UE_F1AP_ID = msg->gNB_CU_ue_id;
+
+  /* mandatory : GNB_DU_UE_F1AP_ID */
+  asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningDeactivationIEs_t, ie2);
+  ie2->id = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+  ie2->criticality = F1AP_Criticality_reject;
+  ie2->value.present = F1AP_PositioningDeactivationIEs__value_PR_GNB_DU_UE_F1AP_ID;
+  ie2->value.choice.GNB_DU_UE_F1AP_ID = msg->gNB_DU_ue_id;
+
+  /* mandatory : CHOICE ABORT TRANSMISSION */
+  asn1cSequenceAdd(out->protocolIEs.list, F1AP_PositioningDeactivationIEs_t, ie3);
+  ie3->id = F1AP_ProtocolIE_ID_id_AbortTransmission;
+  ie3->criticality = F1AP_Criticality_ignore;
+  ie3->value.present = F1AP_PositioningDeactivationIEs__value_PR_AbortTransmission;
+  ie3->value.choice.AbortTransmission = encode_f1ap_abort_transmission(&msg->abort_transmission);
+
+  return pdu;
+}
+
+/**
+ * @brief Decode F1 positioning deactivation
+ */
+bool decode_positioning_deactivation(const F1AP_F1AP_PDU_t *pdu, f1ap_positioning_deactivation_t *out)
+{
+  DevAssert(out != NULL);
+  memset(out, 0, sizeof(*out));
+
+  F1AP_PositioningDeactivation_t *in = &pdu->choice.initiatingMessage->value.choice.PositioningDeactivation;
+  F1AP_PositioningDeactivationIEs_t *ie;
+
+  F1AP_LIB_FIND_IE(F1AP_PositioningDeactivationIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID, true);
+  F1AP_LIB_FIND_IE(F1AP_PositioningDeactivationIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
+  F1AP_LIB_FIND_IE(F1AP_PositioningDeactivationIEs_t, ie, &in->protocolIEs.list, F1AP_ProtocolIE_ID_id_AbortTransmission, true);
+
+  for (int i = 0; i < in->protocolIEs.list.count; ++i) {
+    ie = in->protocolIEs.list.array[i];
+    AssertError(ie != NULL, return false, "in->protocolIEs.list.array[i] is NULL");
+    switch (ie->id) {
+      case F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+        _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningDeactivationIEs__value_PR_GNB_CU_UE_F1AP_ID);
+        out->gNB_CU_ue_id = ie->value.choice.GNB_CU_UE_F1AP_ID;
+        break;
+      case F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+        _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningDeactivationIEs__value_PR_GNB_DU_UE_F1AP_ID);
+        out->gNB_DU_ue_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
+        break;
+      case F1AP_ProtocolIE_ID_id_AbortTransmission:
+        _F1_EQ_CHECK_INT(ie->value.present, F1AP_PositioningDeactivationIEs__value_PR_AbortTransmission);
+        _F1_CHECK_EXP(decode_f1ap_abort_transmission(&ie->value.choice.AbortTransmission, &out->abort_transmission));
+        break;
+      default:
+        PRINT_ERROR("F1AP_ProtocolIE_ID_id %ld unknown, skipping\n", ie->id);
+        break;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @brief F1 positioning deactivation deep copy
+ */
+f1ap_positioning_deactivation_t cp_positioning_deactivation(const f1ap_positioning_deactivation_t *orig)
+{
+  /* copy all mandatory fields that are not dynamic memory */
+  f1ap_positioning_deactivation_t cp = {
+      .gNB_CU_ue_id = orig->gNB_CU_ue_id,
+      .gNB_DU_ue_id = orig->gNB_DU_ue_id,
+      .abort_transmission.present = orig->abort_transmission.present,
+  };
+  // do this properly abort mission
+  switch (orig->abort_transmission.present) {
+    case F1AP_ABORT_TRANSMISSION_PR_NOTHING:
+      // nothing to copy
+      break;
+    case F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID:
+      cp.abort_transmission.choice.srs_resource_set_id = orig->abort_transmission.choice.srs_resource_set_id;
+      break;
+    case F1AP_ABORT_TRANSMISSION_PR_RELEASEALL:
+      cp.abort_transmission.choice.release_all = orig->abort_transmission.choice.release_all;
+      break;
+    default:
+      PRINT_ERROR("received illegal Abort Transmission value %d\n", orig->abort_transmission.present);
+      break;
+  }
+
+  return cp;
+}
+
+/**
+ * @brief F1 positioning deactivation equality check
+ */
+bool eq_positioning_deactivation(const f1ap_positioning_deactivation_t *a, const f1ap_positioning_deactivation_t *b)
+{
+  _F1_EQ_CHECK_INT(a->gNB_CU_ue_id, b->gNB_CU_ue_id);
+  _F1_EQ_CHECK_INT(a->gNB_DU_ue_id, b->gNB_DU_ue_id);
+  _F1_EQ_CHECK_INT(a->abort_transmission.present, b->abort_transmission.present);
+  switch (a->abort_transmission.present) {
+    case F1AP_ABORT_TRANSMISSION_PR_NOTHING:
+      // nothing to check
+      break;
+    case F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID:
+      _F1_EQ_CHECK_INT(a->abort_transmission.choice.srs_resource_set_id, b->abort_transmission.choice.srs_resource_set_id);
+      break;
+    case F1AP_ABORT_TRANSMISSION_PR_RELEASEALL:
+      _F1_EQ_CHECK_INT(a->abort_transmission.choice.release_all, b->abort_transmission.choice.release_all);
+      break;
+    default:
+      PRINT_ERROR("received illegal Abort Transmission value %d\n", a->abort_transmission.present);
+      break;
+  }
+
+  return true;
+}
+
+/**
+ * @brief Free Allocated F1 positioning activation failure
+ */
+void free_positioning_deactivation(f1ap_positioning_deactivation_t *msg)
+{
+  // nothing to free
+}
diff --git a/openair2/F1AP/lib/f1ap_positioning.h b/openair2/F1AP/lib/f1ap_positioning.h
index 2f31a24e15..8d36271cb6 100644
--- a/openair2/F1AP/lib/f1ap_positioning.h
+++ b/openair2/F1AP/lib/f1ap_positioning.h
@@ -71,4 +71,11 @@ bool eq_positioning_activation_failure(const f1ap_positioning_activation_failure
                                        const f1ap_positioning_activation_failure_t *b);
 void free_positioning_activation_failure(f1ap_positioning_activation_failure_t *msg);
 
+// positioning deactivation
+struct F1AP_F1AP_PDU *encode_positioning_deactivation(const f1ap_positioning_deactivation_t *msg);
+bool decode_positioning_deactivation(const struct F1AP_F1AP_PDU *pdu, f1ap_positioning_deactivation_t *out);
+f1ap_positioning_deactivation_t cp_positioning_deactivation(const f1ap_positioning_deactivation_t *orig);
+bool eq_positioning_deactivation(const f1ap_positioning_deactivation_t *a, const f1ap_positioning_deactivation_t *b);
+void free_positioning_deactivation(f1ap_positioning_deactivation_t *msg);
+
 #endif /* F1AP_POSITIONING_H_ */
diff --git a/openair2/F1AP/tests/f1ap_lib_test.c b/openair2/F1AP/tests/f1ap_lib_test.c
index 35fcfad23b..f69b12572f 100644
--- a/openair2/F1AP/tests/f1ap_lib_test.c
+++ b/openair2/F1AP/tests/f1ap_lib_test.c
@@ -1746,6 +1746,49 @@ static void test_f1ap_positioning_activation_failure()
   printf("%s() successful\n", __func__);
 }
 
+static void test_f1ap_positioning_deactivation_msg(f1ap_positioning_deactivation_t *orig)
+{
+  F1AP_F1AP_PDU_t *f1enc = encode_positioning_deactivation(orig);
+  F1AP_F1AP_PDU_t *f1dec = f1ap_encode_decode(f1enc);
+  f1ap_msg_free(f1enc);
+
+  f1ap_positioning_deactivation_t decoded = {0};
+  bool ret = decode_positioning_deactivation(f1dec, &decoded);
+  AssertFatal(ret, "decode_positioning_deactivation(): could not decode message\n");
+  f1ap_msg_free(f1dec);
+
+  ret = eq_positioning_deactivation(orig, &decoded);
+  AssertFatal(ret, "eq_positioning_deactivation(): decoded message doesn't match\n");
+  free_positioning_deactivation(&decoded);
+
+  f1ap_positioning_deactivation_t cp = cp_positioning_deactivation(orig);
+  ret = eq_positioning_deactivation(orig, &cp);
+  AssertFatal(ret, "eq_positioning_deactivation(): copied message doesn't match\n");
+  free_positioning_deactivation(orig);
+  free_positioning_deactivation(&cp);
+}
+
+static void test_f1ap_positioning_deactivation()
+{
+  /* Abort Transmission SRS Resource Set ID test*/
+  f1ap_positioning_deactivation_t orig = {
+      .gNB_CU_ue_id = 12,
+      .gNB_DU_ue_id = 19,
+      .abort_transmission.present = F1AP_ABORT_TRANSMISSION_PR_SRSRESOURCESETID,
+      .abort_transmission.choice.srs_resource_set_id = 10,
+  };
+  test_f1ap_positioning_deactivation_msg(&orig);
+
+  /* Abort Transmission release ALL test*/
+  orig.gNB_CU_ue_id = 12;
+  orig.gNB_DU_ue_id = 19;
+  orig.abort_transmission.present = F1AP_ABORT_TRANSMISSION_PR_RELEASEALL;
+  orig.abort_transmission.choice.release_all = true;
+  test_f1ap_positioning_deactivation_msg(&orig);
+
+  printf("%s() successful\n", __func__);
+}
+
 int main()
 {
   test_initial_ul_rrc_message_transfer();
@@ -1778,5 +1821,6 @@ int main()
   test_f1ap_positioning_activation_request();
   test_f1ap_positioning_activation_response();
   test_f1ap_positioning_activation_failure();
+  test_f1ap_positioning_deactivation();
   return 0;
 }