nr-gnb-rrc.h

// Copyright (c) 2011, 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
// Copyright (c) 2018 Fraunhofer ESK : RLF extensions
//
// SPDX-License-Identifier: GPL-2.0-only
//
// Authors:
//   Nicola Baldo <nbaldo@cttc.es>
//   Marco Miozzo <mmiozzo@cttc.es>
//   Manuel Requena <manuel.requena@cttc.es>
// Modified by:
//   Danilo Abrignani <danilo.abrignani@unibo.it> (Carrier Aggregation - GSoC 2015)
//   Biljana Bojovic <biljana.bojovic@cttc.es> (Carrier Aggregation)
//   Vignesh Babu <ns3-dev@esk.fraunhofer.de> (RLF extensions)
 
#ifndef NR_GNB_RRC_H
#define NR_GNB_RRC_H
 
#include "nr-anr-sap.h"
#include "nr-ccm-rrc-sap.h"
#include "nr-component-carrier.h"
#include "nr-epc-gnb-s1-sap.h"
#include "nr-epc-x2-sap.h"
#include "nr-gnb-cmac-sap.h"
#include "nr-gnb-cphy-sap.h"
#include "nr-handover-management-sap.h"
#include "nr-mac-sap.h"
#include "nr-pdcp-sap.h"
#include "nr-rrc-sap.h"
 
#include <ns3/event-id.h>
#include <ns3/nstime.h>
#include <ns3/object.h>
#include <ns3/traced-callback.h>
 
#include <map>
#include <set>
#include <vector>
 
namespace ns3
{
class BandwidthPartGnb;
 
class NrRadioBearerInfo;
class NrSignalingRadioBearerInfo;
class NrDataRadioBearerInfo;
class NrGnbRrc;
class Packet;
 
class NrUeManager : public Object
{
    friend class NrPdcpSpecificNrPdcpSapUser<NrUeManager>;
 
  public:
    enum State
    {
        INITIAL_RANDOM_ACCESS = 0,
        CONNECTION_SETUP,
        CONNECTION_REJECTED,
        ATTACH_REQUEST,
        CONNECTED_NORMALLY,
        CONNECTION_RECONFIGURATION,
        CONNECTION_REESTABLISHMENT,
        HANDOVER_PREPARATION,
        HANDOVER_JOINING,
        HANDOVER_PATH_SWITCH,
        HANDOVER_LEAVING,
        NUM_STATES
    };
 
    NrUeManager();
 
    NrUeManager(Ptr<NrGnbRrc> rrc, uint16_t rnti, State s, uint8_t componentCarrierId);
 
    ~NrUeManager() override;
 
    void Configure();
 
  protected:
    // inherited from Object
    void DoDispose() override;
 
  public:
    static TypeId GetTypeId();
 
    void SetSource(uint16_t sourceCellId, uint16_t sourceX2apId);
 
    void SetImsi(uint64_t imsi);
 
    void InitialContextSetupRequest();
 
    void ConfigureSap();
 
    void ConfigureSrb0();
 
    void ConfigureSrb1();
 
    void ConfigureMacPhy();
 
    void SetupDataRadioBearer(NrEpsBearer bearer,
                              uint8_t bearerId,
                              uint32_t gtpTeid,
                              Ipv4Address transportLayerAddress);
 
    void RecordDataRadioBearersToBeStarted();
 
    void StartDataRadioBearers();
 
    void ReleaseDataRadioBearer(uint8_t drbid);
 
    void ScheduleRrcConnectionReconfiguration();
 
    void PrepareHandover(uint16_t cellId);
 
    void RecvHandoverRequestAck(NrEpcX2SapUser::HandoverRequestAckParams params);
 
    NrRrcSap::RadioResourceConfigDedicated GetRadioResourceConfigForHandoverPreparationInfo();
 
    NrRrcSap::RrcConnectionReconfiguration GetRrcConnectionReconfigurationForHandover(
        uint8_t componentCarrierId);
 
    void SendData(uint8_t bid, Ptr<Packet> p);
 
    std::vector<NrEpcX2Sap::ErabToBeSetupItem> GetErabList();
 
    void SendUeContextRelease();
 
    void RecvHandoverPreparationFailure(uint16_t cellId);
 
    void RecvSnStatusTransfer(NrEpcX2SapUser::SnStatusTransferParams params);
 
    void RecvUeContextRelease(NrEpcX2SapUser::UeContextReleaseParams params);
 
    void RecvHandoverCancel(NrEpcX2SapUser::HandoverCancelParams params);
 
    // METHODS FORWARDED FROM gNB RRC SAP ///////////////////////////////////////
 
    void CompleteSetupUe(NrGnbRrcSapProvider::CompleteSetupUeParameters params);
    void RecvRrcConnectionRequest(NrRrcSap::RrcConnectionRequest msg);
    void RecvRrcConnectionSetupCompleted(NrRrcSap::RrcConnectionSetupCompleted msg);
    void RecvRrcConnectionReconfigurationCompleted(
        NrRrcSap::RrcConnectionReconfigurationCompleted msg);
    void RecvRrcConnectionReestablishmentRequest(NrRrcSap::RrcConnectionReestablishmentRequest msg);
    void RecvRrcConnectionReestablishmentComplete(
        NrRrcSap::RrcConnectionReestablishmentComplete msg);
    void RecvMeasurementReport(NrRrcSap::MeasurementReport msg);
    void RecvIdealUeContextRemoveRequest(uint16_t rnti);
 
    // METHODS FORWARDED FROM gNB CMAC SAP //////////////////////////////////////
 
    void CmacUeConfigUpdateInd(NrGnbCmacSapUser::UeConfig cmacParams);
 
    // METHODS FORWARDED FROM gNB PDCP SAP //////////////////////////////////////
 
    void DoReceivePdcpSdu(NrPdcpSapUser::ReceivePdcpSduParameters params);
 
    uint16_t GetRnti() const;
 
    uint64_t GetImsi() const;
 
    uint8_t GetComponentCarrierId() const;
 
    uint16_t GetSrsConfigurationIndex() const;
 
    void SetSrsConfigurationIndex(uint16_t srsConfIndex);
 
    State GetState() const;
 
    void SetPdschConfigDedicated(NrRrcSap::PdschConfigDedicated pdschConfigDedicated);
 
    void CancelPendingEvents();
 
    void SendRrcConnectionRelease();
 
    NrEpcX2Sap::HandoverPreparationFailureParams BuildHoPrepFailMsg();
 
    NrEpcX2Sap::HandoverCancelParams BuildHoCancelMsg();
 
    typedef void (*StateTracedCallback)(const uint64_t imsi,
                                        const uint16_t cellId,
                                        const uint16_t rnti,
                                        const State oldState,
                                        const State newState);
 
  private:
    uint8_t AddDataRadioBearerInfo(Ptr<NrDataRadioBearerInfo> radioBearerInfo);
 
    Ptr<NrDataRadioBearerInfo> GetDataRadioBearerInfo(uint8_t drbid);
 
    void RemoveDataRadioBearerInfo(uint8_t drbid);
 
    NrRrcSap::RrcConnectionReconfiguration BuildRrcConnectionReconfiguration();
 
    NrRrcSap::NonCriticalExtensionConfiguration BuildNonCriticalExtensionConfigurationCa();
 
    NrRrcSap::RadioResourceConfigDedicated BuildRadioResourceConfigDedicated();
 
    uint8_t GetNewRrcTransactionIdentifier();
 
    uint8_t Lcid2Drbid(uint8_t lcid);
 
    uint8_t Drbid2Lcid(uint8_t drbid);
 
    uint8_t Lcid2Bid(uint8_t lcid);
 
    uint8_t Bid2Lcid(uint8_t bid);
 
    uint8_t Drbid2Bid(uint8_t drbid);
 
    uint8_t Bid2Drbid(uint8_t bid);
 
    void SendPacket(uint8_t bid, Ptr<Packet> p);
 
    void SwitchToState(State s);
 
    uint8_t m_lastAllocatedDrbid; 
 
    std::map<uint8_t, Ptr<NrDataRadioBearerInfo>> m_drbMap;
 
    Ptr<NrSignalingRadioBearerInfo> m_srb0;
    Ptr<NrSignalingRadioBearerInfo> m_srb1;
 
    uint16_t m_rnti;
    uint64_t m_imsi;
    uint8_t m_componentCarrierId;
 
    uint8_t m_lastRrcTransactionIdentifier; 
 
    NrRrcSap::PhysicalConfigDedicated m_physicalConfigDedicated; 
    Ptr<NrGnbRrc> m_rrc;
    State m_state;
 
    NrPdcpSapUser* m_drbPdcpSapUser; 
 
    bool m_pendingRrcConnectionReconfiguration; 
 
    TracedCallback<uint64_t, uint16_t, uint16_t, State, State> m_stateTransitionTrace;
 
    TracedCallback<uint64_t, uint16_t, uint16_t, uint8_t> m_drbCreatedTrace;
 
    uint16_t m_sourceX2apId;              
    uint16_t m_targetX2apId;              
    uint16_t m_sourceCellId;              
    uint16_t m_targetCellId;              
    std::list<uint8_t> m_drbsToBeStarted; 
    bool m_needPhyMacConfiguration;       
 
    EventId m_connectionRequestTimeout;
    EventId m_connectionSetupTimeout;
    EventId m_connectionRejectedTimeout;
    EventId m_handoverJoiningTimeout;
    EventId m_handoverLeavingTimeout;
 
    bool m_caSupportConfigured;
 
    bool m_pendingStartDataRadioBearers;
 
    std::list<std::pair<uint8_t, Ptr<Packet>>> m_packetBuffer;
 
}; // end of `class NrUeManager`
 
class NrGnbRrc : public Object
{
    friend class GnbRrcMemberNrGnbCmacSapUser;
    friend class MemberNrHandoverManagementSapUser<NrGnbRrc>;
    friend class MemberNrAnrSapUser<NrGnbRrc>;
    friend class MemberNrGnbRrcSapProvider<NrGnbRrc>;
    friend class NrMemberEpcGnbS1SapUser<NrGnbRrc>;
    friend class NrEpcX2SpecificEpcX2SapUser<NrGnbRrc>;
    friend class NrUeManager;
    friend class MemberNrCcmRrcSapUser<NrGnbRrc>;
 
  public:
    NrGnbRrc();
 
    ~NrGnbRrc() override;
 
    // inherited from Object
  protected:
    void DoDispose() override;
 
  public:
    static TypeId GetTypeId();
 
    void SetEpcX2SapProvider(NrEpcX2SapProvider* s);
 
    NrEpcX2SapUser* GetEpcX2SapUser();
 
    void SetNrGnbCmacSapProvider(NrGnbCmacSapProvider* s);
 
    void SetNrGnbCmacSapProvider(NrGnbCmacSapProvider* s, uint8_t pos);
 
    NrGnbCmacSapUser* GetNrGnbCmacSapUser();
 
    NrGnbCmacSapUser* GetNrGnbCmacSapUser(uint8_t pos);
 
    void SetNrHandoverManagementSapProvider(NrHandoverManagementSapProvider* s);
 
    NrHandoverManagementSapUser* GetNrHandoverManagementSapUser();
 
    void SetNrCcmRrcSapProvider(NrCcmRrcSapProvider* s);
 
    NrCcmRrcSapUser* GetNrCcmRrcSapUser();
 
    void SetNrAnrSapProvider(NrAnrSapProvider* s);
 
    NrAnrSapUser* GetNrAnrSapUser();
 
    void SetNrGnbRrcSapUser(NrGnbRrcSapUser* s);
 
    NrGnbRrcSapProvider* GetNrGnbRrcSapProvider();
 
    void SetNrMacSapProvider(NrMacSapProvider* s);
 
    void SetS1SapProvider(NrEpcGnbS1SapProvider* s);
 
    NrEpcGnbS1SapUser* GetS1SapUser();
 
    void SetNrGnbCphySapProvider(NrGnbCphySapProvider* s);
 
    void SetNrGnbCphySapProvider(NrGnbCphySapProvider* s, uint8_t pos);
 
    NrGnbCphySapUser* GetNrGnbCphySapUser();
 
    NrGnbCphySapUser* GetNrGnbCphySapUser(uint8_t pos);
 
    bool HasUeManager(uint16_t rnti) const;
 
    Ptr<NrUeManager> GetUeManager(uint16_t rnti);
 
    std::vector<uint8_t> AddUeMeasReportConfig(NrRrcSap::ReportConfigEutra config);
 
    void ConfigureCell(const std::map<uint8_t, Ptr<BandwidthPartGnb>>& ccPhyConf);
 
    void ConfigureCarriers(std::map<uint8_t, Ptr<BandwidthPartGnb>> ccPhyConf);
 
    void SetCellId(uint16_t m_cellId);
 
    void SetCellId(uint16_t m_cellId, uint8_t ccIndex);
 
    uint8_t CellToComponentCarrierId(uint16_t cellId);
 
    uint16_t ComponentCarrierToCellId(uint8_t componentCarrierId);
 
    bool HasCellId(uint16_t cellId) const;
 
    bool SendData(Ptr<Packet> p);
 
    void SetForwardUpCallback(Callback<void, Ptr<Packet>> cb);
 
    void ConnectionRequestTimeout(uint16_t rnti);
 
    void ConnectionSetupTimeout(uint16_t rnti);
 
    void ConnectionRejectedTimeout(uint16_t rnti);
 
    void HandoverJoiningTimeout(uint16_t rnti);
 
    void HandoverLeavingTimeout(uint16_t rnti);
 
    void SendHandoverRequest(uint16_t rnti, uint16_t cellId);
 
    void DoSendReleaseDataRadioBearer(uint64_t imsi, uint16_t rnti, uint8_t bearerId);
 
    void SendRrcConnectionRelease();
 
    enum NrEpsBearerToRlcMapping_t
    {
        RLC_SM_ALWAYS = 1,
        RLC_UM_ALWAYS = 2,
        RLC_AM_ALWAYS = 3,
        PER_BASED = 4
    };
 
    typedef void (*NewUeContextTracedCallback)(const uint16_t cellId, const uint16_t rnti);
 
    typedef void (*ConnectionHandoverTracedCallback)(const uint64_t imsi,
                                                     const uint16_t cellId,
                                                     const uint16_t rnti);
 
    typedef void (*HandoverStartTracedCallback)(const uint64_t imsi,
                                                const uint16_t cellId,
                                                const uint16_t rnti,
                                                const uint16_t targetCid);
 
    typedef void (*ReceiveReportTracedCallback)(const uint64_t imsi,
                                                const uint16_t cellId,
                                                const uint16_t rnti,
                                                const NrRrcSap::MeasurementReport report);
 
    typedef void (*TimerExpiryTracedCallback)(const uint64_t imsi,
                                              const uint16_t rnti,
                                              const uint16_t cellId,
                                              const std::string cause);
 
    typedef void (*HandoverFailureTracedCallback)(const uint64_t imsi,
                                                  const uint16_t rnti,
                                                  const uint16_t cellId);
 
  private:
    // RRC SAP methods
 
    void DoCompleteSetupUe(uint16_t rnti, NrGnbRrcSapProvider::CompleteSetupUeParameters params);
    void DoRecvRrcConnectionRequest(uint16_t rnti, NrRrcSap::RrcConnectionRequest msg);
    void DoRecvRrcConnectionSetupCompleted(uint16_t rnti,
                                           NrRrcSap::RrcConnectionSetupCompleted msg);
    void DoRecvRrcConnectionReconfigurationCompleted(
        uint16_t rnti,
        NrRrcSap::RrcConnectionReconfigurationCompleted msg);
    void DoRecvRrcConnectionReestablishmentRequest(
        uint16_t rnti,
        NrRrcSap::RrcConnectionReestablishmentRequest msg);
    void DoRecvRrcConnectionReestablishmentComplete(
        uint16_t rnti,
        NrRrcSap::RrcConnectionReestablishmentComplete msg);
    void DoRecvMeasurementReport(uint16_t rnti, NrRrcSap::MeasurementReport msg);
    void DoRecvIdealUeContextRemoveRequest(uint16_t rnti);
 
    // S1 SAP methods
 
    void DoInitialContextSetupRequest(
        NrEpcGnbS1SapUser::InitialContextSetupRequestParameters params);
    void DoDataRadioBearerSetupRequest(
        NrEpcGnbS1SapUser::DataRadioBearerSetupRequestParameters params);
    void DoPathSwitchRequestAcknowledge(
        NrEpcGnbS1SapUser::PathSwitchRequestAcknowledgeParameters params);
 
    // X2 SAP methods
 
    void DoRecvHandoverRequest(NrEpcX2SapUser::HandoverRequestParams params);
    void DoRecvHandoverRequestAck(NrEpcX2SapUser::HandoverRequestAckParams params);
    void DoRecvHandoverPreparationFailure(NrEpcX2SapUser::HandoverPreparationFailureParams params);
    void DoRecvSnStatusTransfer(NrEpcX2SapUser::SnStatusTransferParams params);
    void DoRecvUeContextRelease(NrEpcX2SapUser::UeContextReleaseParams params);
    void DoRecvLoadInformation(NrEpcX2SapUser::LoadInformationParams params);
    void DoRecvResourceStatusUpdate(NrEpcX2SapUser::ResourceStatusUpdateParams params);
    void DoRecvUeData(NrEpcX2SapUser::UeDataParams params);
    void DoRecvHandoverCancel(NrEpcX2SapUser::HandoverCancelParams params);
 
    // CMAC SAP methods
 
    uint16_t DoAllocateTemporaryCellRnti(uint8_t componentCarrierId);
    void DoNotifyLcConfigResult(uint16_t rnti, uint8_t lcid, bool success);
    void DoRrcConfigurationUpdateInd(NrGnbCmacSapUser::UeConfig params);
 
    // Handover Management SAP methods
 
    std::vector<uint8_t> DoAddUeMeasReportConfigForHandover(
        NrRrcSap::ReportConfigEutra reportConfig);
    uint8_t DoAddUeMeasReportConfigForComponentCarrier(NrRrcSap::ReportConfigEutra reportConfig);
    void DoSetNumberOfComponentCarriers(uint16_t numberOfComponentCarriers);
 
    void DoTriggerHandover(uint16_t rnti, uint16_t targetCellId);
 
    // ANR SAP methods
 
    uint8_t DoAddUeMeasReportConfigForAnr(NrRrcSap::ReportConfigEutra reportConfig);
 
    void DoSetPdschConfigDedicated(uint16_t rnti, NrRrcSap::PdschConfigDedicated pa);
    void DoSendLoadInformation(NrEpcX2Sap::LoadInformationParams params);
 
    // Internal methods
 
    uint16_t AddUe(NrUeManager::State state, uint8_t componentCarrierId);
 
    void RemoveUe(uint16_t rnti);
 
    TypeId GetRlcType(NrEpsBearer bearer);
 
    bool IsRandomAccessCompleted(uint16_t rnti);
 
  public:
    void AddX2Neighbour(uint16_t cellId);
 
    void SetSrsPeriodicity(uint32_t p);
 
    uint32_t GetSrsPeriodicity() const;
 
    void SetCsgId(uint32_t csgId, bool csgIndication);
 
  private:
    uint16_t GetNewSrsConfigurationIndex();
 
    void RemoveSrsConfigurationIndex(uint16_t srcCi);
 
    bool IsMaxSrsReached();
 
    uint8_t GetLogicalChannelGroup(NrEpsBearer bearer);
 
    uint8_t GetLogicalChannelPriority(NrEpsBearer bearer);
 
    void SendSystemInformation();
 
    Callback<void, Ptr<Packet>> m_forwardUpCallback; 
 
    NrEpcX2SapUser* m_x2SapUser;
    NrEpcX2SapProvider* m_x2SapProvider;
 
    std::vector<NrGnbCmacSapUser*> m_cmacSapUser;
    std::vector<NrGnbCmacSapProvider*> m_cmacSapProvider;
 
    NrHandoverManagementSapUser* m_handoverManagementSapUser;
    NrHandoverManagementSapProvider* m_handoverManagementSapProvider;
 
    NrCcmRrcSapUser* m_ccmRrcSapUser;
    NrCcmRrcSapProvider* m_ccmRrcSapProvider;
 
    NrAnrSapUser* m_anrSapUser;
    NrAnrSapProvider* m_anrSapProvider;
 
    NrGnbRrcSapUser* m_rrcSapUser;
    NrGnbRrcSapProvider* m_rrcSapProvider;
 
    NrMacSapProvider* m_macSapProvider;
 
    NrEpcGnbS1SapProvider* m_s1SapProvider;
    NrEpcGnbS1SapUser* m_s1SapUser;
 
    std::vector<NrGnbCphySapUser*> m_cphySapUser;
    std::vector<NrGnbCphySapProvider*> m_cphySapProvider;
 
    bool m_configured;
    uint32_t m_dlEarfcn;
    uint32_t m_ulEarfcn;
    uint16_t m_dlBandwidth;
    uint16_t m_ulBandwidth;
    uint16_t m_lastAllocatedRnti;
 
    std::vector<NrRrcSap::SystemInformationBlockType1> m_sib1;
 
    std::map<uint16_t, Ptr<NrUeManager>> m_ueMap;
 
    NrRrcSap::MeasConfig m_ueMeasConfig;
 
    std::set<uint8_t> m_handoverMeasIds;
    std::set<uint8_t> m_anrMeasIds;
    std::set<uint8_t> m_componentCarrierMeasIds;
 
    struct X2uTeidInfo
    {
        uint16_t rnti; 
        uint8_t drbid; 
    };
 
    std::map<uint32_t, X2uTeidInfo> m_x2uTeidInfoMap;
 
    uint8_t m_defaultTransmissionMode;
    NrEpsBearerToRlcMapping_t m_epsBearerToRlcMapping;
    Time m_systemInformationPeriodicity;
    uint16_t m_srsCurrentPeriodicityId;              
    std::set<uint16_t> m_ueSrsConfigurationIndexSet; 
    uint16_t m_lastAllocatedConfigurationIndex;      
    bool m_reconfigureUes;                           
 
    int8_t m_qRxLevMin;
    bool m_admitHandoverRequest;
    bool m_admitRrcConnectionRequest;
    uint8_t m_rsrpFilterCoefficient;
    uint8_t m_rsrqFilterCoefficient;
    Time m_connectionRequestTimeoutDuration;
    Time m_connectionSetupTimeoutDuration;
    Time m_connectionRejectedTimeoutDuration;
    Time m_handoverJoiningTimeoutDuration;
    Time m_handoverLeavingTimeoutDuration;
 
    TracedCallback<uint16_t, uint16_t> m_newUeContextTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_connectionEstablishedTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_connectionReconfigurationTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t, uint16_t> m_handoverStartTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_handoverEndOkTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t, NrRrcSap::MeasurementReport>
        m_recvMeasurementReportTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_connectionReleaseTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t, std::string> m_rrcTimeoutTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_handoverFailureNoPreambleTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_handoverFailureMaxRachTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_handoverFailureLeavingTrace;
    TracedCallback<uint64_t, uint16_t, uint16_t> m_handoverFailureJoiningTrace;
 
    uint16_t m_numberOfComponentCarriers; 
 
    bool m_carriersConfigured; 
 
    std::map<uint8_t, Ptr<BandwidthPartGnb>>
        m_componentCarrierPhyConf; 
 
}; // end of `class NrGnbRrc`
 
} // namespace ns3
 
#endif // NR_GNB_RRC_H