UE changes: Handling of ulsyncvalidityduration IE in sib19

Spec 38.331 section 5.2.2.4.21 indicates this
1> start or restart T430 for serving cell with the timer value set to ntn-UlSyncValidityDuration for the serving cell
from the subframe indicated by epochTime for the serving cell;
NOTE: UE should attempt to re-acquire SIB19 before the end of the duration indicated by ntn-UlSyncValidityDuration and epochTime

Epochtime IE
When explicitly provided through SIB, or through dedicated signaling, the EpochTime is the starting time of a DL
sub-frame, indicated by a SFN and a sub-frame number signaled together with the assistance information.
For serving cell, the field sfn indicates the current SFN or the next upcoming SFN after the frame where the message indicating the epochTime is received.
This field is mandatory present when ntn-Config is provided in dedicated configuration.

gNB implementation related to epochtime will be done in a separate merge request.

openair2/LAYER2/NR_MAC_UE/mac_proto.h

@@ -67,13 +67,16 @@ void release_common_ss_cset(NR_BWP_PDCCH_t *pdcch);
    \param gNB_index      gNB index
    \param sibs_mask      sibs mask
    \param pduP           pointer to pdu
-   \param pdu_length     length of pdu */
+   \param pdu_length     length of pdu
+   \param frame,slot     Received TTI*/
 void nr_ue_decode_BCCH_DL_SCH(NR_UE_MAC_INST_t *mac,
                               int cc_id,
                               unsigned int gNB_index,
                               uint8_t ack_nack,
                               uint8_t *pduP,
-                              uint32_t pdu_len);
+                              uint32_t pdu_len,
+                              int frame,
+                              int slot);
 
 void release_dl_BWP(NR_UE_MAC_INST_t *mac, int index);
 void release_ul_BWP(NR_UE_MAC_INST_t *mac, int index);

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -305,11 +305,13 @@ void nr_ue_decode_BCCH_DL_SCH(NR_UE_MAC_INST_t *mac,
                               unsigned int gNB_index,
                               uint8_t ack_nack,
                               uint8_t *pduP,
-                              uint32_t pdu_len)
+                              uint32_t pdu_len,
+                              int frame,
+                              int slot)
 {
   if(ack_nack) {
     LOG_D(NR_MAC, "Decoding NR-BCCH-DL-SCH-Message (SIB1 or SI)\n");
-    nr_mac_rrc_data_ind_ue(mac->ue_id, cc_id, gNB_index, 0, 0, 0, mac->physCellId, 0, NR_BCCH_DL_SCH, (uint8_t *) pduP, pdu_len);
+    nr_mac_rrc_data_ind_ue(mac->ue_id, cc_id, gNB_index, frame, slot, 0, mac->physCellId, 0, NR_BCCH_DL_SCH, (uint8_t *) pduP, pdu_len);
     if (mac->get_sib1)
       mac->get_sib1 = false;
     for (int i = 0; i < MAX_SI_GROUPS; i++) {
@@ -325,7 +327,7 @@ void nr_ue_decode_BCCH_DL_SCH(NR_UE_MAC_INST_t *mac,
   }
   else {
     LOG_E(NR_MAC, "Got NACK on NR-BCCH-DL-SCH-Message (%s)\n", mac->get_sib1 ? "SIB1" : "other SI");
-    nr_mac_rrc_data_ind_ue(mac->ue_id, cc_id, gNB_index, 0, 0, 0, mac->physCellId, 0, NR_BCCH_DL_SCH, NULL, 0);
+    nr_mac_rrc_data_ind_ue(mac->ue_id, cc_id, gNB_index, frame, slot, 0, mac->physCellId, 0, NR_BCCH_DL_SCH, NULL, 0);
   }
 }
 

openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c

@@ -1106,9 +1106,11 @@ static int handle_bcch_dlsch(NR_UE_MAC_INST_t *mac,
                              unsigned int gNB_index,
                              uint8_t ack_nack,
                              uint8_t *pduP,
-                             uint32_t pdu_len)
+                             uint32_t pdu_len,
+                             int frame,
+                             int slot)
 {
-  nr_ue_decode_BCCH_DL_SCH(mac, cc_id, gNB_index, ack_nack, pduP, pdu_len);
+  nr_ue_decode_BCCH_DL_SCH(mac, cc_id, gNB_index, ack_nack, pduP, pdu_len, frame, slot);
   return 0;
 }
 
@@ -1290,10 +1292,13 @@ static uint32_t nr_ue_dl_processing(NR_UE_MAC_INST_t *mac, nr_downlink_indicatio
           break;
         case FAPI_NR_RX_PDU_TYPE_SIB:
           ret_mask |= (handle_bcch_dlsch(mac,
-                                         dl_info->cc_id, dl_info->gNB_index,
+                                         dl_info->cc_id,
+                                         dl_info->gNB_index,
                                          rx_indication_body.pdsch_pdu.ack_nack,
                                          rx_indication_body.pdsch_pdu.pdu,
-                                         rx_indication_body.pdsch_pdu.pdu_length)) << FAPI_NR_RX_PDU_TYPE_SIB;
+                                         rx_indication_body.pdsch_pdu.pdu_length,
+                                         dl_info->frame,
+                                         dl_info->slot)) << FAPI_NR_RX_PDU_TYPE_SIB;
           break;
         case FAPI_NR_RX_PDU_TYPE_DLSCH:
           ret_mask |= (handle_dlsch(mac, dl_info, i)) << FAPI_NR_RX_PDU_TYPE_DLSCH;

openair2/RRC/NR_UE/rrc_UE.c

@@ -144,7 +144,8 @@ static void process_lte_nsa_msg(NR_UE_RRC_INST_t *rrc, nsa_msg_t *msg, int msg_l
 static void nr_rrc_ue_process_ueCapabilityEnquiry(NR_UE_RRC_INST_t *rrc, NR_UECapabilityEnquiry_t *UECapabilityEnquiry);
 static void nr_rrc_ue_process_masterCellGroup(NR_UE_RRC_INST_t *rrc,
                                               OCTET_STRING_t *masterCellGroup,
-                                              long *fullConfig);
+                                              long *fullConfig,
+                                              int gNB_index);
 
 static void nr_rrc_ue_process_measConfig(rrcPerNB_t *rrc, NR_MeasConfig_t *const measConfig, NR_UE_Timers_Constants_t *timers);
 
@@ -165,7 +166,120 @@ static void set_DRB_status(NR_UE_RRC_INST_t *rrc, NR_DRB_Identity_t drb_id, NR_R
   rrc->status_DRBs[drb_id - 1] = status;
 }
 
-static void nr_decode_SI(NR_UE_RRC_SI_INFO *SI_info, NR_SystemInformation_t *si, NR_UE_RRC_INST_t *rrc)
+static int get_ulsyncvalidityduration_timer_value(NR_NTN_Config_r17_t *ntncfg)
+{
+  int retval = 0;
+  AssertFatal(ntncfg, "NTN-Config IE not present\n");
+
+  if (ntncfg->ntn_UlSyncValidityDuration_r17) {
+    const int values[] = {5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 120, 180, 240, 900};
+    retval = values[*ntncfg->ntn_UlSyncValidityDuration_r17];
+  }
+
+  return retval;
+}
+
+static void get_epochtime_from_sib19scheduling(NR_UE_RRC_SI_INFO *SI_info, int *frame, int *subframe)
+{
+  // TS 38.331 section 5.2.2.3.2
+  // SI-window starts at the slot #a, where a = x mod N
+  // x = (si-WindowPosition -1) × w, where w is the si-WindowLength;
+  // N is the number of slots in a radio frame
+  int wl_slots = 5 << SI_info->si_windowlength;
+  int x = (SI_info->sib19_windowposition - 1) * wl_slots;
+  int slots_per_subframe = 1 << SI_info->scs;
+  int N = slots_per_subframe * 10;
+  int slot_end_sib19_window = (x % N) + wl_slots;
+
+  *frame += (slot_end_sib19_window / N);
+  int slot = slot_end_sib19_window % N;
+  *subframe = ceil(slot / slots_per_subframe);
+
+  LOG_D(NR_RRC,
+        "Get EPOCHTIME: x:%d, N:%d, slot_endw:%d, frame:%d, subframe:%d , slot:%d\n",
+        x,
+        N,
+        slot_end_sib19_window,
+        *frame,
+        *subframe,
+        slot);
+}
+
+static int eval_epoch_time(NR_UE_RRC_SI_INFO *SI_info, NR_NTN_Config_r17_t *ntncfg, int frame)
+{
+  int epoch_frame = 0, epoch_subframe = 0;
+  int diff_frames = 0;
+  AssertFatal(frame >= 0, "Frame Incorrect, results in incorrect EPOCH time evaluation\n");
+  if (ntncfg->epochTime_r17) {
+    epoch_frame = ntncfg->epochTime_r17->sfn_r17;
+    epoch_subframe = ntncfg->epochTime_r17->subFrameNR_r17;
+  } else {
+    // EPOCH time is optional in case of SIB19. This case happens only in case of SIB19 NTN config
+    // If no EPOCH time is sent, epochtime points to SIB19 window end slot in the current scheduling window
+    epoch_frame = frame;
+    epoch_subframe = 0;
+    get_epochtime_from_sib19scheduling(SI_info, &epoch_frame, &epoch_subframe);
+    // Adding epochTime IE in SIB19, later MAC will use it.
+    ntncfg->epochTime_r17 = CALLOC(1, sizeof(NR_EpochTime_r17_t));
+    ntncfg->epochTime_r17->sfn_r17 = epoch_frame;
+    ntncfg->epochTime_r17->subFrameNR_r17 = epoch_subframe;
+  }
+  // For serving cell, the field sfn indicates the current SFN or the next upcoming SFN
+  // after the frame where the message indicating the epochTime is received
+  // i.e. Epochframe can be present or future SFN
+  diff_frames = (epoch_frame - frame + 1024) % 1024;    // According to 38.331 Epochtime is defined for serving cell like this
+  LOG_D(NR_RRC, "Epoch frame %d, ahead by %d frames\n", epoch_frame, diff_frames);
+  return diff_frames;
+}
+
+static int get_ntn_timervalues(NR_UE_RRC_SI_INFO *SI_info, NR_NTN_Config_r17_t *ntncfg, int diff_frames, int *val430_ms)
+{
+  int val430 = get_ulsyncvalidityduration_timer_value(ntncfg);
+  int sib19_periodicity_ms = (SI_info->sib19_periodicity + 1) * 10;
+  *val430_ms = val430 * 1000 + diff_frames * 10; // in ms
+  if (*val430_ms <= sib19_periodicity_ms)
+    LOG_E(NR_RRC, "Too small T430 value. Might result in frequent ULSYNC failure\n");
+
+  // Depending on ulsyncvalidity duration, SIB19 timer expires 15secs/2secs before T430
+  // LArger values might be used for GEO and epoch time interval can be around 10 secs
+  // Lower values will be used for NGSO (LEO/MEO), epoch time interval can be between 2-3 secs.
+  // TODO remove the hardoded values and define a better strategy to determine the time of expiry
+  // with real GEO/LEO/MEO SATs.
+  int expire_before_ms = ((val430 >= 120) ? 10000 : 2000);
+  int diff = *val430_ms - expire_before_ms;
+  int sib19_timer_ms = (diff > 0) ? diff : ((*val430_ms - sib19_periodicity_ms) > 0) ? (*val430_ms - sib19_periodicity_ms) : 0;
+  LOG_D(NR_RRC, "val430:%d s, T430:%d ms, sib19_timer:%d ms\n", val430, *val430_ms, sib19_timer_ms);
+  return sib19_timer_ms;
+}
+
+static void nr_rrc_process_ntnconfig(NR_UE_RRC_INST_t *rrc, NR_UE_RRC_SI_INFO *SI_info, NR_NTN_Config_r17_t *ntncfg, int frame)
+{
+  SI_info->SInfo_r17.sib19_validity = true;
+  // Check if Epochtime is sent or not
+  int diff_frames = eval_epoch_time(SI_info, ntncfg, frame);
+
+  if (ntncfg->ntn_UlSyncValidityDuration_r17) { // ulsyncvalidity duration configured
+    int val430_ms = 0, sib19_timer_ms = 0;
+    sib19_timer_ms = get_ntn_timervalues(SI_info, ntncfg, diff_frames, &val430_ms);
+    // T430 should be started only in connected mode.
+    // Inorder to avoid starting T430 when entering connected mode, T430 is started as soon as
+    // SIB19 is received, and if UE enters connected mode T430 will be in running.
+    // T430 expiry in RRC idle or inactive states does nothing.
+    nr_timer_setup(&rrc->timers_and_constants.T430, val430_ms, 10);
+    nr_timer_start(&rrc->timers_and_constants.T430);
+    // SIB19 should be received before T430 expires
+    // SIB19 validity timer should expire before T430 expiry such that new SIB19 is read
+    if (sib19_timer_ms > 0) {
+      nr_timer_setup(&SI_info->SInfo_r17.sib19_timer, sib19_timer_ms, 10);
+      nr_timer_start(&SI_info->SInfo_r17.sib19_timer);
+    } else
+      // This makes sure that SIB19 is read again in the next window
+      SI_info->SInfo_r17.sib19_validity = false;
+  } else
+    nr_timer_start(&SI_info->SInfo_r17.sib19_timer);
+}
+
+static void nr_decode_SI(NR_UE_RRC_SI_INFO *SI_info, NR_SystemInformation_t *si, NR_UE_RRC_INST_t *rrc, int frame)
 {
   instance_t ue_id = rrc->ue_id;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SI, VCD_FUNCTION_IN);
@@ -240,11 +354,10 @@ static void nr_decode_SI(NR_UE_RRC_SI_INFO *SI_info, NR_SystemInformation_t *si,
         nr_timer_start(&SI_info->sib14_timer);
         break;
       case NR_SystemInformation_IEs__sib_TypeAndInfo__Member_PR_sib19_v1700:
-        SI_info->SInfo_r17.sib19_validity = true;
-        if (g_log->log_component[NR_RRC].level >= OAILOG_DEBUG)
-          xer_fprint(stdout, &asn_DEF_NR_SIB19_r17, (const void *)typeandinfo->choice.sib19_v1700);
         sib19 = typeandinfo->choice.sib19_v1700;
-        nr_timer_start(&SI_info->SInfo_r17.sib19_timer);
+        if (g_log->log_component[NR_RRC].level >= OAILOG_DEBUG)
+          xer_fprint(stdout, &asn_DEF_NR_SIB19_r17, (const void *)sib19);
+        nr_rrc_process_ntnconfig(rrc, SI_info, sib19->ntn_Config_r17, frame);
         break;
       default:
         break;
@@ -335,6 +448,27 @@ static bool verify_NTN_access(const NR_UE_RRC_SI_INFO *SI_info, const NR_SIB1_v1
   return ntn_access && sib19_present;
 }
 
+static void get_sib19_schedinfo(NR_UE_RRC_SI_INFO *SI_info, NR_SI_SchedulingInfo_v1700_t *si_SchedInfo_v1700)
+{
+  // Find the SIB19 periodicity configured in the scheduling info
+  if (si_SchedInfo_v1700) {
+    int count_v17 = si_SchedInfo_v1700->schedulingInfoList2_r17.list.count;
+    for (int i = 0; i < count_v17; i++) {
+      struct NR_SchedulingInfo2_r17 *schedulingInfo2 = si_SchedInfo_v1700->schedulingInfoList2_r17.list.array[i];
+      for (int j = 0; j < schedulingInfo2->sib_MappingInfo_r17.list.count; j++) {
+        struct NR_SIB_TypeInfo_v1700 *sib_TypeInfo_v1700 = schedulingInfo2->sib_MappingInfo_r17.list.array[j];
+        if (sib_TypeInfo_v1700->sibType_r17.present == NR_SIB_TypeInfo_v1700__sibType_r17_PR_type1_r17) {
+          if (sib_TypeInfo_v1700->sibType_r17.choice.type1_r17 == NR_SIB_TypeInfo_v1700__sibType_r17__type1_r17_sibType19) {
+            SI_info->sib19_periodicity = 8 << schedulingInfo2->si_Periodicity_r17;
+            SI_info->sib19_windowposition = schedulingInfo2->si_WindowPosition_r17;
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
 static void nr_rrc_process_sib1(NR_UE_RRC_INST_t *rrc, NR_UE_RRC_SI_INFO *SI_info, NR_SIB1_t *sib1)
 {
   if(g_log->log_component[NR_RRC].level >= OAILOG_DEBUG)
@@ -355,9 +489,14 @@ static void nr_rrc_process_sib1(NR_UE_RRC_INST_t *rrc, NR_UE_RRC_SI_INFO *SI_inf
     si_SchedInfo_v1700 = sib1_v1700->si_SchedulingInfo_v1700;
   }
 
+  AssertFatal(sib1->servingCellConfigCommon, "configuration issue in SIB1\n");
+  SI_info->scs = sib1->servingCellConfigCommon->downlinkConfigCommon.initialDownlinkBWP.genericParameters.subcarrierSpacing;
+  SI_info->si_windowlength = (sib1->si_SchedulingInfo) ? sib1->si_SchedulingInfo->si_WindowLength : 0;
   // configure default SI
   nr_rrc_configure_default_SI(SI_info, sib1->si_SchedulingInfo, si_SchedInfo_v1700);
   rrc->is_NTN_UE = verify_NTN_access(SI_info, sib1_v1700);
+  if (rrc->is_NTN_UE)
+    get_sib19_schedinfo(SI_info, si_SchedInfo_v1700);
 
   // configure timers and constant
   nr_rrc_set_sib1_timers_and_constants(&rrc->timers_and_constants, sib1);
@@ -376,7 +515,7 @@ static void nr_rrc_process_reconfiguration_v1530(NR_UE_RRC_INST_t *rrc, NR_RRCRe
     LOG_E(NR_RRC, "RRCReconfiguration includes fullConfig but this is not implemented yet\n");
   }
   if (rec_1530->masterCellGroup)
-    nr_rrc_ue_process_masterCellGroup(rrc, rec_1530->masterCellGroup, rec_1530->fullConfig);
+    nr_rrc_ue_process_masterCellGroup(rrc, rec_1530->masterCellGroup, rec_1530->fullConfig, gNB_index);
   if (rec_1530->masterKeyUpdate) {
     // TODO perform AS security key update procedure as specified in 5.3.5.7
     LOG_E(NR_RRC, "RRCReconfiguration includes masterKeyUpdate but this is not implemented yet\n");
@@ -426,7 +565,7 @@ static void nr_rrc_process_reconfiguration_v1530(NR_UE_RRC_INST_t *rrc, NR_RRCRe
       SEQUENCE_free(&asn_DEF_NR_SystemInformation, si, 1);
     } else {
       LOG_I(NR_RRC, "[UE %ld] Decoding dedicatedSystemInformationDelivery\n", rrc->ue_id);
-      nr_decode_SI(SI_info, si, rrc);
+      nr_decode_SI(SI_info, si, rrc, rrc->current_frame);
     }
   }
   if (rec_1530->otherConfig) {
@@ -502,7 +641,7 @@ static void nr_rrc_ue_process_rrcReconfiguration(NR_UE_RRC_INST_t *rrc, int gNB_
         if (LOG_DEBUGFLAG(DEBUG_ASN1))
           xer_fprint(stdout, &asn_DEF_NR_CellGroupConfig, (const void *) cellGroupConfig);
 
-        nr_rrc_cellgroup_configuration(rrc, cellGroupConfig);
+        nr_rrc_cellgroup_configuration(rrc, cellGroupConfig, gNB_index);
 
         AssertFatal(!IS_SA_MODE(get_softmodem_params()), "secondaryCellGroup only used in NSA for now\n");
         MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_CG);
@@ -924,7 +1063,9 @@ static void nr_rrc_ue_decode_NR_BCCH_DL_SCH_Message(NR_UE_RRC_INST_t *rrc,
                                                     uint8_t *const Sdu,
                                                     const uint8_t Sdu_len,
                                                     const uint8_t rsrq,
-                                                    const uint8_t rsrp)
+                                                    const uint8_t rsrp,
+                                                    int frame,
+                                                    int slot)
 {
   NR_UE_RRC_SI_INFO *SI_info = &rrc->perNB[gNB_index].SInfo;
   SI_info->sib_pending = false;
@@ -960,9 +1101,9 @@ static void nr_rrc_ue_decode_NR_BCCH_DL_SCH_Message(NR_UE_RRC_INST_t *rrc,
         bcch_message->message.choice.c1->choice.systemInformationBlockType1 = NULL;
         break;
       case NR_BCCH_DL_SCH_MessageType__c1_PR_systemInformation:
-        LOG_I(NR_RRC, "[UE %ld] Decoding SI\n", rrc->ue_id);
+        LOG_I(NR_RRC, "[UE %ld] %d:%d Decoding SI\n", rrc->ue_id, frame, slot);
         NR_SystemInformation_t *si = bcch_message->message.choice.c1->choice.systemInformation;
-        nr_decode_SI(SI_info, si, rrc);
+        nr_decode_SI(SI_info, si, rrc, frame);
         break;
       case NR_BCCH_DL_SCH_MessageType__c1_PR_NOTHING:
       default:
@@ -1019,7 +1160,9 @@ static void nr_rrc_manage_rlc_bearers(NR_UE_RRC_INST_t *rrc,
   }
 }
 
-static void nr_rrc_process_reconfigurationWithSync(NR_UE_RRC_INST_t *rrc, NR_ReconfigurationWithSync_t *reconfigurationWithSync)
+static void nr_rrc_process_reconfigurationWithSync(NR_UE_RRC_INST_t *rrc,
+                                                   NR_ReconfigurationWithSync_t *reconfigurationWithSync,
+                                                   int gNB_index)
 {
   // perform Reconfiguration with sync according to 5.3.5.5.2
   if (!rrc->as_security_activated && !(get_softmodem_params()->phy_test || get_softmodem_params()->do_ra)) {
@@ -1046,15 +1189,26 @@ static void nr_rrc_process_reconfigurationWithSync(NR_UE_RRC_INST_t *rrc, NR_Rec
   }
   rrc->rnti = reconfigurationWithSync->newUE_Identity;
   // reset the MAC entity of this cell group (done at MAC in handle_reconfiguration_with_sync)
+
+  // 3GPP TS38.331 section 5.3.5.5.2
+  nr_timer_stop(&tac->T430);
+  if (reconfigurationWithSync->spCellConfigCommon &&
+      reconfigurationWithSync->spCellConfigCommon->ext2 &&
+      reconfigurationWithSync->spCellConfigCommon->ext2->ntn_Config_r17) {
+    NR_NTN_Config_r17_t *ntncfg = reconfigurationWithSync->spCellConfigCommon->ext2->ntn_Config_r17;
+    // EPOCH time is always sent if NTN config is sent through DCCH
+    AssertFatal(ntncfg->epochTime_r17, "NTN-CONFIG sent in dedicated mode should have EPOCHTIME\n");
+    nr_rrc_process_ntnconfig(rrc, &rrc->perNB[gNB_index].SInfo, ntncfg, rrc->current_frame);
+  }
 }
 
-void nr_rrc_cellgroup_configuration(NR_UE_RRC_INST_t *rrc, NR_CellGroupConfig_t *cellGroupConfig)
+void nr_rrc_cellgroup_configuration(NR_UE_RRC_INST_t *rrc, NR_CellGroupConfig_t *cellGroupConfig, int gNB_index)
 {
   NR_SpCellConfig_t *spCellConfig = cellGroupConfig->spCellConfig;
   if(spCellConfig) {
     if (spCellConfig->reconfigurationWithSync) {
       LOG_I(NR_RRC, "Processing reconfigurationWithSync\n");
-      nr_rrc_process_reconfigurationWithSync(rrc, spCellConfig->reconfigurationWithSync);
+      nr_rrc_process_reconfigurationWithSync(rrc, spCellConfig->reconfigurationWithSync, gNB_index);
     }
     nr_rrc_handle_SetupRelease_RLF_TimersAndConstants(rrc, spCellConfig->rlf_TimersAndConstants);
     if (spCellConfig->spCellConfigDedicated) {
@@ -1074,10 +1228,10 @@ void nr_rrc_cellgroup_configuration(NR_UE_RRC_INST_t *rrc, NR_CellGroupConfig_t
   AssertFatal(cellGroupConfig->sCellToAddModList == NULL, "Secondary serving cell addition not implemented\n");
 }
 
-
 static void nr_rrc_ue_process_masterCellGroup(NR_UE_RRC_INST_t *rrc,
                                               OCTET_STRING_t *masterCellGroup,
-                                              long *fullConfig)
+                                              long *fullConfig,
+                                              int gNB_index)
 {
   AssertFatal(!fullConfig, "fullConfig not supported yet\n");
   NR_CellGroupConfig_t *cellGroupConfig = NULL;
@@ -1091,7 +1245,7 @@ static void nr_rrc_ue_process_masterCellGroup(NR_UE_RRC_INST_t *rrc,
     xer_fprint(stdout, &asn_DEF_NR_CellGroupConfig, (const void *) cellGroupConfig);
   }
 
-  nr_rrc_cellgroup_configuration(rrc, cellGroupConfig);
+  nr_rrc_cellgroup_configuration(rrc, cellGroupConfig, gNB_index);
 
   LOG_D(RRC, "Sending CellGroupConfig to MAC the pointer will be managed by mac\n");
   MessageDef *msg = itti_alloc_new_message(TASK_RRC_NRUE, 0, NR_MAC_RRC_CONFIG_CG);
@@ -1150,9 +1304,7 @@ static void nr_rrc_process_rrcsetup(NR_UE_RRC_INST_t *rrc, const NR_RRCSetup_t *
   }
 
   // perform the cell group configuration procedure in accordance with the received masterCellGroup
-  nr_rrc_ue_process_masterCellGroup(rrc,
-                                    &rrcSetup->criticalExtensions.choice.rrcSetup->masterCellGroup,
-                                    NULL);
+  nr_rrc_ue_process_masterCellGroup(rrc, &rrcSetup->criticalExtensions.choice.rrcSetup->masterCellGroup, NULL, 0);
   // perform the radio bearer configuration procedure in accordance with the received radioBearerConfig
   nr_rrc_ue_process_RadioBearerConfig(rrc,
                                       &rrcSetup->criticalExtensions.choice.rrcSetup->radioBearerConfig);
@@ -1999,7 +2151,8 @@ void *rrc_nrue(void *notUsed)
   } break;
 
   case NRRRC_FRAME_PROCESS:
-    LOG_D(NR_RRC, "Received %s: frame %d\n", ITTI_MSG_NAME(msg_p), NRRRC_FRAME_PROCESS(msg_p).frame);
+    rrc->current_frame = NRRRC_FRAME_PROCESS(msg_p).frame;
+    LOG_D(NR_RRC, "Received %s: frame %d\n", ITTI_MSG_NAME(msg_p), rrc->current_frame);
     // increase the timers every 10ms (every new frame)
     nr_rrc_handle_timers(rrc);
     NR_UE_RRC_SI_INFO *SInfo = &rrc->perNB[NRRRC_FRAME_PROCESS(msg_p).gnb_id].SInfo;
@@ -2043,7 +2196,14 @@ void *rrc_nrue(void *notUsed)
     if (bcch->is_bch)
       nr_rrc_ue_decode_NR_BCCH_BCH_Message(rrc, bcch->gnb_index, bcch->phycellid, bcch->ssb_arfcn, bcch->sdu, bcch->sdu_size);
     else
-      nr_rrc_ue_decode_NR_BCCH_DL_SCH_Message(rrc, bcch->gnb_index, bcch->sdu, bcch->sdu_size, bcch->rsrq, bcch->rsrp);
+      nr_rrc_ue_decode_NR_BCCH_DL_SCH_Message(rrc,
+                                              bcch->gnb_index,
+                                              bcch->sdu,
+                                              bcch->sdu_size,
+                                              bcch->rsrq,
+                                              bcch->rsrp,
+                                              bcch->frame,
+                                              bcch->slot);
     break;
 
   case NR_RRC_MAC_SBCCH_DATA_IND:

openair2/RRC/NR_UE/rrc_defs.h

@@ -151,6 +151,11 @@ typedef struct UE_RRC_SI_INFO_NR_s {
   bool sib14_validity;
   NR_timer_t sib14_timer;
   NR_UE_RRC_SI_INFO_r17 SInfo_r17;
+  // Extracted from SIB1
+  int scs;
+  int sib19_periodicity;
+  int sib19_windowposition;
+  int si_windowlength;
 } NR_UE_RRC_SI_INFO;
 
 typedef struct NR_UE_Timers_Constants_s {
@@ -167,6 +172,8 @@ typedef struct NR_UE_Timers_Constants_s {
   NR_timer_t T325;
   NR_timer_t T380;
   NR_timer_t T390;
+  // NTN timer T430 which guards UL SYNC
+  NR_timer_t T430;
   // counters
   uint32_t N310_cnt;
   uint32_t N311_cnt;
@@ -233,6 +240,8 @@ typedef struct NR_UE_RRC_INST_s {
   bool reconfig_after_reestab;
   // 5G-S-TMSI
   uint64_t fiveG_S_TMSI;
+  // Frame timing received from MAC
+  int current_frame;
 
   //Sidelink params
   NR_SL_PreconfigurationNR_r16_t *sl_preconfig;

openair2/RRC/NR_UE/rrc_proto.h

@@ -47,7 +47,7 @@ void init_nsa_message (NR_UE_RRC_INST_t *rrc, char* reconfig_file, char* rbconfi
 
 void process_nsa_message(NR_UE_RRC_INST_t *rrc, nsa_message_t nsa_message_type, void *message, int msg_len);
 
-void nr_rrc_cellgroup_configuration(NR_UE_RRC_INST_t *rrc, NR_CellGroupConfig_t *cellGroupConfig);
+void nr_rrc_cellgroup_configuration(NR_UE_RRC_INST_t *rrc, NR_CellGroupConfig_t *cellGroupConfig, int gNB_index);
 
 void nr_rrc_going_to_IDLE(NR_UE_RRC_INST_t *rrc,
                           NR_Release_Cause_t release_cause,

openair2/RRC/NR_UE/rrc_timers_and_constants.c

@@ -169,6 +169,14 @@ void nr_rrc_handle_timers(NR_UE_RRC_INST_t *rrc)
     // with release cause 'RRC connection failure'
     nr_rrc_going_to_IDLE(rrc, RRC_CONNECTION_FAILURE, NULL);
   }
+
+  bool t430_expired = nr_timer_tick(&rrc->timers_and_constants.T430);
+  if (t430_expired && rrc->nrRrcState == RRC_STATE_CONNECTED_NR && rrc->is_NTN_UE) {
+    LOG_W(NR_RRC, "Timer T430 expired! NTN UL SYNC FAILURE\n");
+    // Upon T430 expiry, the UE shall reacquire SIB19 and re-obtain UL-SYNC
+    // Spec 38.331 Section 5.2.2.6
+    AssertFatal(1 == 0, "UL-Sync Lost. Read SIB19, perform RACH and obtain UL-SYNC. NOT YET Implemented.\n");
+  }
 }
 
 int nr_rrc_get_T304(long t304)