nr-ue-mac.h

// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef NR_UE_MAC_H
#define NR_UE_MAC_H
 
#include "nr-ccm-mac-sap.h"
#include "nr-phy-mac-common.h"
#include "nr-ue-cmac-sap.h"
 
#include "ns3/traced-callback.h"
 
#include <unordered_map>
 
namespace ns3
{
 
class NrUePhySapUser;
class NrPhySapProvider;
class NrControlMessage;
class UniformRandomVariable;
class PacketBurst;
class NrUlDciMessage;
 
class NrUeMac : public Object
{
    friend class UeMemberNrUeCmacSapProvider;
    friend class UeMemberNrMacSapProvider;
    friend class MacUeMemberPhySapUser;
 
  public:
    static TypeId GetTypeId();
 
    NrUeMac();
    ~NrUeMac() override;
 
    enum SrBsrMachine : uint8_t
    {
        INACTIVE, 
        TO_SEND,  
        ACTIVE 
    };
 
    void SetUeCmacSapUser(NrUeCmacSapUser* s);
 
    NrUeCmacSapProvider* GetUeCmacSapProvider();
 
    NrMacSapProvider* GetUeMacSapProvider();
 
    NrUePhySapUser* GetPhySapUser();
 
    void SetPhySapProvider(NrPhySapProvider* ptr);
 
    typedef void (*RxedUeMacCtrlMsgsTracedCallback)(const SfnSf sfnSf,
                                                    const uint16_t nodeId,
                                                    const uint16_t rnti,
                                                    const uint8_t bwpId,
                                                    Ptr<NrControlMessage> ctrlMessage);
    typedef void (*TxedUeMacCtrlMsgsTracedCallback)(const SfnSf sfnSf,
                                                    const uint16_t nodeId,
                                                    const uint16_t rnti,
                                                    const uint8_t bwpId,
                                                    Ptr<NrControlMessage> ctrlMessage);
 
    typedef void (*UeMacStateMachineTracedCallback)(
        const SfnSf sfnSf,
        const uint16_t nodeId,
        const uint16_t rnti,
        const uint8_t bwpId,
        const enum SrBsrMachine srState,
        std::unordered_map<uint8_t, NrMacSapProvider::BufferStatusReportParameters> ulBsrReceived,
        int retx,
        std::string nameFunc);
 
    void SetNumHarqProcess(uint8_t numHarqProcesses);
 
    uint8_t GetNumHarqProcess() const;
 
    uint16_t GetBwpId() const;
 
    uint16_t GetCellId() const;
 
    uint16_t GetRnti() const;
 
    uint64_t GetImsi() const;
 
    int64_t AssignStreams(int64_t stream);
 
  protected:
    void DoDispose() override;
 
    void SetCurrentSlot(const SfnSf& sfn);
 
    virtual int64_t DoAssignStreams(int64_t stream);
 
  private:
    void RecvRaResponse(NrBuildRarListElement_s raResponse);
    void SetRnti(uint16_t);
    virtual void DoSlotIndication(const SfnSf& sfn);
 
    uint32_t GetTotalBufSize() const __attribute__((warn_unused_result));
 
    void SendSR() const;
    void DoTransmitPdu(NrMacSapProvider::TransmitPduParameters params);
 
    void DoTransmitBufferStatusReport(NrMacSapProvider::BufferStatusReportParameters params);
 
    // forwarded from PHY SAP
    void DoReceivePhyPdu(Ptr<Packet> p);
    void DoReceiveControlMessage(Ptr<NrControlMessage> msg);
    // void DoNotifyHarqDeliveryFailure (uint8_t harqId);
    void RaResponseTimeout(bool contention);
 
    // forwarded from UE CMAC SAP
    void DoConfigureRach(NrUeCmacSapProvider::RachConfig rc);
    void DoStartContentionBasedRandomAccessProcedure();
    void DoStartNonContentionBasedRandomAccessProcedure(uint16_t rnti,
                                                        uint8_t rapId,
                                                        uint8_t prachMask);
    void AddLc(uint8_t lcId, NrUeCmacSapProvider::LogicalChannelConfig lcConfig, NrMacSapUser* msu);
    void DoRemoveLc(uint8_t lcId);
    void DoReset();
    void DoNotifyConnectionSuccessful();
    void DoSetImsi(uint64_t imsi);
 
    void RandomlySelectAndSendRaPreamble();
    void SendRaPreamble(bool contention);
 
    void SendBufferStatusReport(const SfnSf& dataSfn, uint8_t symStart);
    void RefreshHarqProcessesPacketBuffer();
 
    void ProcessUlDci(const Ptr<NrUlDciMessage>& dciMsg);
 
    void TransmitRetx();
 
    void SendNewData();
 
    void SendNewStatusData();
 
    void SendRetxData(uint32_t usefulTbs, uint32_t activeRetx);
 
    void SendTxData(uint32_t usefulTbs, uint32_t activeTx);
 
  private:
    NrUeCmacSapUser* m_cmacSapUser{nullptr};
    NrUeCmacSapProvider* m_cmacSapProvider{nullptr};
    NrPhySapProvider* m_phySapProvider{nullptr};
    NrUePhySapUser* m_phySapUser{nullptr};
    NrMacSapProvider* m_macSapProvider{nullptr};
 
    SfnSf m_currentSlot;          
    uint8_t m_numHarqProcess{20}; 
 
    std::shared_ptr<DciInfoElementTdma>
        m_ulDci;                  
    SfnSf m_ulDciSfnsf;           
    uint32_t m_ulDciTotalUsed{0}; 
 
    std::unordered_map<uint8_t, NrMacSapProvider::BufferStatusReportParameters>
        m_ulBsrReceived; 
 
    SrBsrMachine m_srState{INACTIVE}; 
 
    Ptr<UniformRandomVariable> m_raPreambleUniformVariable;
    uint8_t m_raPreambleId{0}; 
    uint8_t m_raRnti{0};       
    uint64_t m_imsi{0};        
 
    // The HARQ part has to be reviewed
    struct UlHarqProcessInfo
    {
        Ptr<PacketBurst> m_pktBurst;
        // maintain list of LCs contained in this TB
        // used to signal HARQ failure to RLC handlers
        std::vector<uint8_t> m_lcidList;
    };
 
    // uint8_t m_harqProcessId;
    std::vector<UlHarqProcessInfo>
        m_miUlHarqProcessesPacket; 
    std::vector<uint8_t> m_miUlHarqProcessesPacketTimer; 
 
    struct LcInfo
    {
        NrUeCmacSapProvider::LogicalChannelConfig lcConfig;
        NrMacSapUser* macSapUser;
    };
 
    std::unordered_map<uint8_t, LcInfo> m_lcInfoMap;       
    uint16_t m_rnti{std::numeric_limits<uint16_t>::max()}; 
 
    bool m_waitingForRaResponse{true}; 
    static uint8_t g_raPreambleId;     
 
    TracedCallback<SfnSf, uint16_t, uint16_t, uint8_t, Ptr<const NrControlMessage>>
        m_macRxedCtrlMsgsTrace;
 
    TracedCallback<SfnSf, uint16_t, uint16_t, uint8_t, Ptr<const NrControlMessage>>
        m_macTxedCtrlMsgsTrace;
 
    TracedCallback<uint64_t, bool, uint8_t, uint8_t> m_raResponseTimeoutTrace;
 
    TracedCallback<SfnSf,
                   uint16_t,
                   uint16_t,
                   uint8_t,
                   SrBsrMachine,
                   std::unordered_map<uint8_t, NrMacSapProvider::BufferStatusReportParameters>,
                   int,
                   std::string>
        m_macUeStateMachine;
 
    void StartWaitingForRaResponse();
    bool m_rachConfigured = false;                
    NrUeCmacSapProvider::RachConfig m_rachConfig; 
    uint8_t m_preambleTransmissionCounter{0};     
    EventId m_noRaResponseReceivedEvent;          
};
 
} // namespace ns3
 
#endif /* NR_UE_MAC_H */