diff --git a/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h b/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h
index 291f45d8e398b82555d1da9fae1f6ec1dffa1ce8..31f1700dc9af3a243e5a56918ada028a299b507d 100644
--- a/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h
+++ b/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h
@@ -42,6 +42,7 @@ bool eq_ul_dci_request(const nfapi_nr_ul_dci_request_t *a, const nfapi_nr_ul_dci
 bool eq_tx_data_request(const nfapi_nr_tx_data_request_t *a, const nfapi_nr_tx_data_request_t *b);
 bool eq_rx_data_indication(const nfapi_nr_rx_data_indication_t *a, const nfapi_nr_rx_data_indication_t *b);
 bool eq_crc_indication(const nfapi_nr_crc_indication_t *a, const nfapi_nr_crc_indication_t *b);
+bool eq_uci_indication(const nfapi_nr_uci_indication_t *a, const nfapi_nr_uci_indication_t *b);
 
 void free_dl_tti_request(nfapi_nr_dl_tti_request_t *msg);
 void free_ul_tti_request(nfapi_nr_ul_tti_request_t *msg);
@@ -50,6 +51,7 @@ void free_ul_dci_request(nfapi_nr_ul_dci_request_t *msg);
 void free_tx_data_request(nfapi_nr_tx_data_request_t *msg);
 void free_rx_data_indication(nfapi_nr_rx_data_indication_t *msg);
 void free_crc_indication(nfapi_nr_crc_indication_t *msg);
+void free_uci_indication(nfapi_nr_uci_indication_t *msg);
 
 void copy_dl_tti_request(const nfapi_nr_dl_tti_request_t *src, nfapi_nr_dl_tti_request_t *dst);
 void copy_ul_tti_request(const nfapi_nr_ul_tti_request_t *src, nfapi_nr_ul_tti_request_t *dst);
@@ -58,9 +60,11 @@ void copy_ul_dci_request(const nfapi_nr_ul_dci_request_t *src, nfapi_nr_ul_dci_r
 void copy_tx_data_request(const nfapi_nr_tx_data_request_t *src, nfapi_nr_tx_data_request_t *dst);
 void copy_rx_data_indication(const nfapi_nr_rx_data_indication_t *src, nfapi_nr_rx_data_indication_t *dst);
 void copy_crc_indication(const nfapi_nr_crc_indication_t *src, nfapi_nr_crc_indication_t *dst);
+void copy_uci_indication(const nfapi_nr_uci_indication_t *src, nfapi_nr_uci_indication_t *dst);
 
 
 size_t get_tx_data_request_size(const nfapi_nr_tx_data_request_t *msg);
 size_t get_rx_data_indication_size(const nfapi_nr_rx_data_indication_t *msg);
 size_t get_crc_indication_size(const nfapi_nr_crc_indication_t *msg);
+size_t get_uci_indication_size(const nfapi_nr_uci_indication_t *msg);
 #endif // OPENAIRINTERFACE_NR_FAPI_P7_UTILS_H
diff --git a/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c b/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c
index 148c5e430d5c9cf886fc8a9bea03f5c1ab277a03..a7699cea89640be4f5ab11cd90dddff71e661e48 100644
--- a/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c
+++ b/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c
@@ -625,6 +625,170 @@ bool eq_crc_indication(const nfapi_nr_crc_indication_t *a, const nfapi_nr_crc_in
   return true;
 }
 
+bool eq_uci_indication_sr_pdu_0_1(const nfapi_nr_sr_pdu_0_1_t *a, const nfapi_nr_sr_pdu_0_1_t *b)
+{
+  EQ(a->sr_indication, b->sr_indication);
+  EQ(a->sr_confidence_level, b->sr_confidence_level);
+  return true;
+}
+
+bool eq_uci_indication_sr_pdu_2_3_4(const nfapi_nr_sr_pdu_2_3_4_t *a, const nfapi_nr_sr_pdu_2_3_4_t *b)
+{
+  EQ(a->sr_bit_len, b->sr_bit_len);
+  for (int i = 0; i < (a->sr_bit_len / 8) + 1; ++i) {
+    EQ(a->sr_payload[i], b->sr_payload[i]);
+  }
+  return true;
+}
+
+bool eq_uci_indication_harq_pdu_0_1(const nfapi_nr_harq_pdu_0_1_t *a, const nfapi_nr_harq_pdu_0_1_t *b)
+{
+  EQ(a->num_harq, b->num_harq);
+  EQ(a->harq_confidence_level, b->harq_confidence_level);
+  for (int i = 0; i < a->num_harq; ++i) {
+    EQ(a->harq_list[i].harq_value, b->harq_list[i].harq_value);
+  }
+  return true;
+}
+
+bool eq_uci_indication_harq_pdu_2_3_4(const nfapi_nr_harq_pdu_2_3_4_t *a, const nfapi_nr_harq_pdu_2_3_4_t *b)
+{
+  EQ(a->harq_crc, b->harq_crc);
+  EQ(a->harq_bit_len, b->harq_bit_len);
+  for (int i = 0; i < (a->harq_bit_len / 8) + 1; ++i) {
+    EQ(a->harq_payload[i], b->harq_payload[i]);
+  }
+  return true;
+}
+
+bool eq_uci_indication_csi_part1(const nfapi_nr_csi_part1_pdu_t *a, const nfapi_nr_csi_part1_pdu_t *b)
+{
+  EQ(a->csi_part1_crc, b->csi_part1_crc);
+  EQ(a->csi_part1_bit_len, b->csi_part1_bit_len);
+  for (int i = 0; i < (a->csi_part1_bit_len / 8) + 1; ++i) {
+    EQ(a->csi_part1_payload[i], b->csi_part1_payload[i]);
+  }
+  return true;
+}
+
+bool eq_uci_indication_csi_part2(const nfapi_nr_csi_part2_pdu_t *a, const nfapi_nr_csi_part2_pdu_t *b)
+{
+  EQ(a->csi_part2_crc, b->csi_part2_crc);
+  EQ(a->csi_part2_bit_len, b->csi_part2_bit_len);
+  for (int i = 0; i < (a->csi_part2_bit_len / 8) + 1; ++i) {
+    EQ(a->csi_part2_payload[i], b->csi_part2_payload[i]);
+  }
+  return true;
+}
+
+bool eq_uci_indication_PUSCH(const nfapi_nr_uci_pusch_pdu_t *a, const nfapi_nr_uci_pusch_pdu_t *b)
+{
+  EQ(a->pduBitmap, b->pduBitmap);
+  EQ(a->handle, b->handle);
+  EQ(a->rnti, b->rnti);
+  EQ(a->ul_cqi, b->ul_cqi);
+  EQ(a->timing_advance, b->timing_advance);
+  EQ(a->rssi, b->rssi);
+
+  // Bit 0 not used in PUSCH PDU
+  // HARQ
+  if ((a->pduBitmap >> 1) & 0x01) {
+    EQ(eq_uci_indication_harq_pdu_2_3_4(&a->harq, &b->harq), true);
+  }
+  // CSI Part 1
+  if ((a->pduBitmap >> 2) & 0x01) {
+    EQ(eq_uci_indication_csi_part1(&a->csi_part1, &b->csi_part1), true);
+  }
+  // CSI Part 2
+  if ((a->pduBitmap >> 3) & 0x01) {
+    EQ(eq_uci_indication_csi_part2(&a->csi_part2, &b->csi_part2), true);
+  }
+  return true;
+}
+
+bool eq_uci_indication_PUCCH_0_1(const nfapi_nr_uci_pucch_pdu_format_0_1_t *a, const nfapi_nr_uci_pucch_pdu_format_0_1_t *b)
+{
+  EQ(a->pduBitmap, b->pduBitmap);
+  EQ(a->handle, b->handle);
+  EQ(a->rnti, b->rnti);
+  EQ(a->pucch_format, b->pucch_format);
+  EQ(a->ul_cqi, b->ul_cqi);
+  EQ(a->timing_advance, b->timing_advance);
+  EQ(a->rssi, b->rssi);
+
+  // SR
+  if (a->pduBitmap & 0x01) {
+    EQ(eq_uci_indication_sr_pdu_0_1(&a->sr, &b->sr), true);
+  }
+  // HARQ
+  if ((a->pduBitmap >> 1) & 0x01) {
+    EQ(eq_uci_indication_harq_pdu_0_1(&a->harq, &b->harq), true);
+  }
+  return true;
+}
+
+bool eq_uci_indication_PUCCH_2_3_4(const nfapi_nr_uci_pucch_pdu_format_2_3_4_t *a, const nfapi_nr_uci_pucch_pdu_format_2_3_4_t *b)
+{
+  EQ(a->pduBitmap, b->pduBitmap);
+  EQ(a->handle, b->handle);
+  EQ(a->rnti, b->rnti);
+  EQ(a->pucch_format, b->pucch_format);
+  EQ(a->ul_cqi, b->ul_cqi);
+  EQ(a->timing_advance, b->timing_advance);
+  EQ(a->rssi, b->rssi);
+  // SR
+  if (a->pduBitmap & 0x01) {
+    EQ(eq_uci_indication_sr_pdu_2_3_4(&a->sr, &b->sr), true);
+  }
+  // HARQ
+  if ((a->pduBitmap >> 1) & 0x01) {
+    EQ(eq_uci_indication_harq_pdu_2_3_4(&a->harq, &b->harq), true);
+  }
+  // CSI Part 1
+  if ((a->pduBitmap >> 2) & 0x01) {
+    EQ(eq_uci_indication_csi_part1(&a->csi_part1, &b->csi_part1), true);
+  }
+  // CSI Part 2
+  if ((a->pduBitmap >> 3) & 0x01) {
+    EQ(eq_uci_indication_csi_part2(&a->csi_part2, &b->csi_part2), true);
+  }
+  return true;
+}
+
+bool eq_uci_indication_UCI(const nfapi_nr_uci_t *a, const nfapi_nr_uci_t *b)
+{
+  EQ(a->pdu_type, b->pdu_type);
+  EQ(a->pdu_size, b->pdu_size);
+  switch (a->pdu_type) {
+    case NFAPI_NR_UCI_PUSCH_PDU_TYPE:
+      EQ(eq_uci_indication_PUSCH(&a->pusch_pdu, &b->pusch_pdu), true);
+      break;
+    case NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE:
+      EQ(eq_uci_indication_PUCCH_0_1(&a->pucch_pdu_format_0_1, &b->pucch_pdu_format_0_1), true);
+      break;
+    case NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE:
+      EQ(eq_uci_indication_PUCCH_2_3_4(&a->pucch_pdu_format_2_3_4, &b->pucch_pdu_format_2_3_4), true);
+      break;
+    default:
+      AssertFatal(1 == 0, "Unknown UCI.indication PDU Type %d\n", a->pdu_type);
+      break;
+  }
+  return true;
+}
+
+bool eq_uci_indication(const nfapi_nr_uci_indication_t *a, const nfapi_nr_uci_indication_t *b)
+{
+  EQ(a->header.message_id, b->header.message_id);
+  EQ(a->header.message_length, b->header.message_length);
+  EQ(a->sfn, b->sfn);
+  EQ(a->slot, b->slot);
+  EQ(a->num_ucis, b->num_ucis);
+  for (int crc_idx = 0; crc_idx < a->num_ucis; ++crc_idx) {
+    EQ(eq_uci_indication_UCI(&a->uci_list[crc_idx], &b->uci_list[crc_idx]), true);
+  }
+  return true;
+}
+
 void free_dl_tti_request(nfapi_nr_dl_tti_request_t *msg)
 {
   if (msg->vendor_extension) {
@@ -696,6 +860,76 @@ void free_crc_indication(nfapi_nr_crc_indication_t *msg)
   }
 }
 
+void free_uci_indication(nfapi_nr_uci_indication_t *msg)
+{
+  if (msg->uci_list) {
+    for (int pdu_idx = 0; pdu_idx < msg->num_ucis; ++pdu_idx) {
+      nfapi_nr_uci_t *uci_pdu = &msg->uci_list[pdu_idx];
+      switch (uci_pdu->pdu_type) {
+        case NFAPI_NR_UCI_PUSCH_PDU_TYPE: {
+          nfapi_nr_uci_pusch_pdu_t *pdu = &uci_pdu->pusch_pdu;
+          // Bit 0 not used in PUSCH PDU
+          // HARQ
+          if ((pdu->pduBitmap >> 1) & 0x01) {
+            if (pdu->harq.harq_payload) {
+              free(pdu->harq.harq_payload);
+            }
+          }
+          // CSI Part 1
+          if ((pdu->pduBitmap >> 2) & 0x01) {
+            if (pdu->csi_part1.csi_part1_payload) {
+              free(pdu->csi_part1.csi_part1_payload);
+            }
+          }
+          // CSI Part 2
+          if ((pdu->pduBitmap >> 3) & 0x01) {
+            if (pdu->csi_part2.csi_part2_payload) {
+              free(pdu->csi_part2.csi_part2_payload);
+            }
+          }
+          break;
+        }
+        case NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE: {
+          // Nothing to free
+          break;
+        }
+        case NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE: {
+          nfapi_nr_uci_pucch_pdu_format_2_3_4_t *pdu = &uci_pdu->pucch_pdu_format_2_3_4;
+          // SR
+          if (pdu->pduBitmap & 0x01) {
+            if (pdu->sr.sr_payload) {
+              free(pdu->sr.sr_payload);
+            }
+          }
+          // HARQ
+          if ((pdu->pduBitmap >> 1) & 0x01) {
+            if (pdu->harq.harq_payload) {
+              free(pdu->harq.harq_payload);
+            }
+          }
+          // CSI Part 1
+          if ((pdu->pduBitmap >> 2) & 0x01) {
+            if (pdu->csi_part1.csi_part1_payload) {
+              free(pdu->csi_part1.csi_part1_payload);
+            }
+          }
+          // CSI Part 2
+          if ((pdu->pduBitmap >> 3) & 0x01) {
+            if (pdu->csi_part2.csi_part2_payload) {
+              free(pdu->csi_part2.csi_part2_payload);
+            }
+          }
+          break;
+        }
+        default:
+          AssertFatal(1 == 0, "Unknown UCI.indication PDU Type %d\n", uci_pdu->pdu_type);
+          break;
+      }
+    }
+    free(msg->uci_list);
+  }
+}
+
 static void copy_dl_tti_beamforming(const nfapi_nr_tx_precoding_and_beamforming_t *src,
                                     nfapi_nr_tx_precoding_and_beamforming_t *dst)
 {
@@ -1358,3 +1592,234 @@ size_t get_crc_indication_size(const nfapi_nr_crc_indication_t *msg)
   }
   return total_size;
 }
+
+void copy_uci_indication_sr_pdu_0_1(const nfapi_nr_sr_pdu_0_1_t *src, nfapi_nr_sr_pdu_0_1_t *dst)
+{
+  dst->sr_indication = src->sr_indication;
+  dst->sr_confidence_level = src->sr_confidence_level;
+}
+
+void copy_uci_indication_sr_pdu_2_3_4(const nfapi_nr_sr_pdu_2_3_4_t *src, nfapi_nr_sr_pdu_2_3_4_t *dst)
+{
+  dst->sr_bit_len = src->sr_bit_len;
+  const uint16_t sr_len = (dst->sr_bit_len / 8) + 1;
+  dst->sr_payload = calloc(sr_len, sizeof(*dst->sr_payload));
+  for (int i = 0; i < sr_len; ++i) {
+    dst->sr_payload[i] = src->sr_payload[i];
+  }
+}
+
+void copy_uci_indication_harq_pdu_0_1(const nfapi_nr_harq_pdu_0_1_t *src, nfapi_nr_harq_pdu_0_1_t *dst)
+{
+  dst->num_harq = src->num_harq;
+  dst->harq_confidence_level = src->harq_confidence_level;
+  for (int i = 0; i < dst->num_harq; ++i) {
+    dst->harq_list[i].harq_value = src->harq_list[i].harq_value;
+  }
+}
+
+void copy_uci_indication_harq_pdu_2_3_4(const nfapi_nr_harq_pdu_2_3_4_t *src, nfapi_nr_harq_pdu_2_3_4_t *dst)
+{
+  dst->harq_crc = src->harq_crc;
+  dst->harq_bit_len = src->harq_bit_len;
+  const uint16_t harq_length = (dst->harq_bit_len / 8) + 1;
+  dst->harq_payload = calloc(harq_length, sizeof(*dst->harq_payload));
+  for (int i = 0; i < harq_length; ++i) {
+    dst->harq_payload[i] = src->harq_payload[i];
+  }
+}
+
+void copy_uci_indication_csi_part1(const nfapi_nr_csi_part1_pdu_t *src, nfapi_nr_csi_part1_pdu_t *dst)
+{
+  dst->csi_part1_crc = src->csi_part1_crc;
+  dst->csi_part1_bit_len = src->csi_part1_bit_len;
+  const uint16_t payload_length = (dst->csi_part1_bit_len / 8) + 1;
+  dst->csi_part1_payload = calloc(payload_length, sizeof(*dst->csi_part1_payload));
+  for (int i = 0; i < payload_length; ++i) {
+    dst->csi_part1_payload[i] = src->csi_part1_payload[i];
+  }
+}
+
+void copy_uci_indication_csi_part2(const nfapi_nr_csi_part2_pdu_t *src, nfapi_nr_csi_part2_pdu_t *dst)
+{
+  dst->csi_part2_crc = src->csi_part2_crc;
+  dst->csi_part2_bit_len = src->csi_part2_bit_len;
+  const uint16_t payload_length = (dst->csi_part2_bit_len / 8) + 1;
+  dst->csi_part2_payload = calloc(payload_length, sizeof(*dst->csi_part2_payload));
+  for (int i = 0; i < payload_length; ++i) {
+    dst->csi_part2_payload[i] = src->csi_part2_payload[i];
+  }
+}
+
+void copy_uci_indication_PUSCH(const nfapi_nr_uci_pusch_pdu_t *src, nfapi_nr_uci_pusch_pdu_t *dst)
+{
+  dst->pduBitmap = src->pduBitmap;
+  dst->handle = src->handle;
+  dst->rnti = src->rnti;
+  dst->ul_cqi = src->ul_cqi;
+  dst->timing_advance = src->timing_advance;
+  dst->rssi = src->rssi;
+
+  // Bit 0 not used in PUSCH PDU
+  // HARQ
+  if ((dst->pduBitmap >> 1) & 0x01) {
+    copy_uci_indication_harq_pdu_2_3_4(&src->harq, &dst->harq);
+  }
+  // CSI Part 1
+  if ((dst->pduBitmap >> 2) & 0x01) {
+    copy_uci_indication_csi_part1(&src->csi_part1, &dst->csi_part1);
+  }
+  // CSI Part 2
+  if ((dst->pduBitmap >> 3) & 0x01) {
+    copy_uci_indication_csi_part2(&src->csi_part2, &dst->csi_part2);
+  }
+}
+
+void copy_uci_indication_PUCCH_0_1(const nfapi_nr_uci_pucch_pdu_format_0_1_t *src, nfapi_nr_uci_pucch_pdu_format_0_1_t *dst)
+{
+  dst->pduBitmap = src->pduBitmap;
+  dst->handle = src->handle;
+  dst->rnti = src->rnti;
+  dst->pucch_format = src->pucch_format;
+  dst->ul_cqi = src->ul_cqi;
+  dst->timing_advance = src->timing_advance;
+  dst->rssi = src->rssi;
+
+  // SR
+  if (dst->pduBitmap & 0x01) {
+    copy_uci_indication_sr_pdu_0_1(&src->sr, &dst->sr);
+  }
+  // HARQ
+  if ((dst->pduBitmap >> 1) & 0x01) {
+    copy_uci_indication_harq_pdu_0_1(&src->harq, &dst->harq);
+  }
+}
+
+void copy_uci_indication_PUCCH_2_3_4(const nfapi_nr_uci_pucch_pdu_format_2_3_4_t *src, nfapi_nr_uci_pucch_pdu_format_2_3_4_t *dst)
+{
+  dst->pduBitmap = src->pduBitmap;
+  dst->handle = src->handle;
+  dst->rnti = src->rnti;
+  dst->pucch_format = src->pucch_format;
+  dst->ul_cqi = src->ul_cqi;
+  dst->timing_advance = src->timing_advance;
+  dst->rssi = src->rssi;
+  // SR
+  if (dst->pduBitmap & 0x01) {
+    copy_uci_indication_sr_pdu_2_3_4(&src->sr, &dst->sr);
+  }
+  // HARQ
+  if ((dst->pduBitmap >> 1) & 0x01) {
+    copy_uci_indication_harq_pdu_2_3_4(&src->harq, &dst->harq);
+  }
+  // CSI Part 1
+  if ((dst->pduBitmap >> 2) & 0x01) {
+    copy_uci_indication_csi_part1(&src->csi_part1, &dst->csi_part1);
+  }
+  // CSI Part 2
+  if ((dst->pduBitmap >> 3) & 0x01) {
+    copy_uci_indication_csi_part2(&src->csi_part2, &dst->csi_part2);
+  }
+}
+
+void copy_uci_indication_UCI(const nfapi_nr_uci_t *src, nfapi_nr_uci_t *dst)
+{
+  dst->pdu_type = src->pdu_type;
+  dst->pdu_size = src->pdu_size;
+  switch (dst->pdu_type) {
+    case NFAPI_NR_UCI_PUSCH_PDU_TYPE:
+      copy_uci_indication_PUSCH(&src->pusch_pdu, &dst->pusch_pdu);
+      break;
+    case NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE:
+      copy_uci_indication_PUCCH_0_1(&src->pucch_pdu_format_0_1, &dst->pucch_pdu_format_0_1);
+      break;
+    case NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE:
+      copy_uci_indication_PUCCH_2_3_4(&src->pucch_pdu_format_2_3_4, &dst->pucch_pdu_format_2_3_4);
+      break;
+    default:
+      AssertFatal(1 == 0, "Unknown UCI.indication PDU Type %d\n", src->pdu_type);
+      break;
+  }
+}
+
+void copy_uci_indication(const nfapi_nr_uci_indication_t *src, nfapi_nr_uci_indication_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  dst->sfn = src->sfn;
+  dst->slot = src->slot;
+  dst->num_ucis = src->num_ucis;
+  dst->uci_list = calloc(dst->num_ucis, sizeof(*dst->uci_list));
+  for (int crc_idx = 0; crc_idx < src->num_ucis; ++crc_idx) {
+    copy_uci_indication_UCI(&src->uci_list[crc_idx], &dst->uci_list[crc_idx]);
+  }
+}
+
+size_t get_uci_indication_size(const nfapi_nr_uci_indication_t *msg)
+{
+  // Get size of the message (allocated pointer included)
+  size_t total_size = 0;
+
+  // Header and fixed-size fields
+  total_size += sizeof(msg->header);
+  total_size += sizeof(msg->sfn);
+  total_size += sizeof(msg->slot);
+  total_size += sizeof(msg->num_ucis);
+
+  // Loop through each UCI in the uci_list
+  for (int uci_idx = 0; uci_idx < msg->num_ucis; ++uci_idx) {
+    const nfapi_nr_uci_t *uci_pdu = &msg->uci_list[uci_idx];
+
+    total_size += sizeof(uci_pdu->pdu_type);
+    total_size += sizeof(uci_pdu->pdu_size);
+
+    switch (uci_pdu->pdu_type) {
+      case NFAPI_NR_UCI_PUSCH_PDU_TYPE:
+        total_size += sizeof(uci_pdu->pusch_pdu);
+
+        // HARQ payload, CSI Part 1 and 2 are conditionally allocated
+        if ((uci_pdu->pusch_pdu.pduBitmap >> 1) & 0x01) {
+          total_size += uci_pdu->pusch_pdu.harq.harq_bit_len / 8 + 1;
+        }
+        if ((uci_pdu->pusch_pdu.pduBitmap >> 2) & 0x01) {
+          total_size += uci_pdu->pusch_pdu.csi_part1.csi_part1_bit_len / 8 + 1;
+        }
+        if ((uci_pdu->pusch_pdu.pduBitmap >> 3) & 0x01) {
+          total_size += uci_pdu->pusch_pdu.csi_part2.csi_part2_bit_len / 8 + 1;
+        }
+        break;
+
+      case NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE:
+        total_size += sizeof(uci_pdu->pucch_pdu_format_0_1);
+        // SR and HARQ are conditionally filled, but neither require calloc inside
+        break;
+
+      case NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE:
+        total_size += sizeof(uci_pdu->pucch_pdu_format_2_3_4);
+
+        // SR, HARQ, CSI Part 1, and CSI Part 2 are conditionally allocated
+        if (uci_pdu->pucch_pdu_format_2_3_4.pduBitmap & 0x01) {
+          total_size += uci_pdu->pucch_pdu_format_2_3_4.sr.sr_bit_len / 8 + 1;
+        }
+        if ((uci_pdu->pucch_pdu_format_2_3_4.pduBitmap >> 1) & 0x01) {
+          total_size += uci_pdu->pucch_pdu_format_2_3_4.harq.harq_bit_len / 8 + 1;
+        }
+        if ((uci_pdu->pucch_pdu_format_2_3_4.pduBitmap >> 2) & 0x01) {
+          total_size += uci_pdu->pucch_pdu_format_2_3_4.csi_part1.csi_part1_bit_len / 8 + 1;
+        }
+        if ((uci_pdu->pucch_pdu_format_2_3_4.pduBitmap >> 3) & 0x01) {
+          total_size += uci_pdu->pucch_pdu_format_2_3_4.csi_part2.csi_part2_bit_len / 8 + 1;
+        }
+        break;
+
+      default:
+        AssertFatal(1 == 0, "Unknown UCI.indication PDU Type %d\n", uci_pdu->pdu_type);
+        break;
+    }
+  }
+
+  // Finally, add the size of the uci_list pointer itself
+  total_size += msg->num_ucis * sizeof(*msg->uci_list);
+
+  return total_size;
+}
diff --git a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c
index 92677eaf1bb741356905c96a3e4938a6b155c89a..1222d0f74db22a49e931be929a2bbffe7fa21c39 100644
--- a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c
+++ b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c
@@ -2689,7 +2689,7 @@ static uint8_t pack_nr_uci_pucch_2_3_4(void* tlv, uint8_t **ppWritePackedMsg, ui
     return 0;
   if (!push16(value->rnti, ppWritePackedMsg, end))
     return 0;
-  if (!push8(value->pucch_format-2, ppWritePackedMsg, end))
+  if (!push8(value->pucch_format, ppWritePackedMsg, end))
     return 0;
   if (!push8(value->ul_cqi, ppWritePackedMsg, end))
     return 0;
@@ -4829,7 +4829,6 @@ static uint8_t unpack_nr_uci_pucch_2_3_4(nfapi_nr_uci_pucch_pdu_format_2_3_4_t*
 	if (!pull16(ppReadPackedMsg, &value->rssi, end))
                 return 0;
 
-  value->pucch_format += 2;
 	if (value->pduBitmap & 0x01) { //SR
 		if (!pull16(ppReadPackedMsg, &value->sr.sr_bit_len, end))
 			return 0;