GenericMuxedInterruptDistributor.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
#include "../NDRegisterAccessor.h"
#include "../RegisterPath.h"
#include "MuxedInterruptDistributor.h"
 
#include <atomic>
#include <bitset>
#include <chrono>
#include <map>
#include <memory>
#include <thread>
 
namespace ChimeraTK::async {
 
  enum GmidOptionCode {
    ISR = 0, // Interrupt Status Register
    IER,     // Interrupt Enable Register
    MER,     // Master Enable Register,
    MIE,     // Master Interrupt Enable  Functionally equivalent to MER
    GIE,     // Global Interrupt Enable, Functionally equivalent to MER
    ICR,     // Interrupt Clear Register
    IAR,     // Interrupt Acknowledge Register
    IPR,     // Interrupt Pending Register =ISR & IER, a convenience feature for software.
    SIE,     // Set Interrupt Enable
    CIE,     // Clear Interrupt Enable
    IMaskR,  // Interrupt Mask Register. IMR Acronym Collision. Temporarily not allowed. See
    IModeR,  // Interrupt Mode Register. IMR Acronym Collision, defined in the standard but not allowed; REMOVE?
    IVR,     // defined in the standard but not allowed; REMOVE?
    ILR,     // defined in the standard but not allowed; REMOVE?
    IVAR,    // defined in the standard but not allowed; REMOVE?
    IVEAR,   // defined in the standard but not allowed; REMOVE?
    OPTION_CODE_COUNT, // used for counting how many valid enums there are here & setting list lengths
    INVALID_OPTION_CODE,
  };
 
  /********************************************************************************************************************/
 
  class GenericMuxedInterruptDistributor : public MuxedInterruptDistributor {
   public:
    explicit GenericMuxedInterruptDistributor(const boost::shared_ptr<SubDomain<std::nullptr_t>>& parent,
        const std::string& registerPath, std::bitset<(ulong)GmidOptionCode::OPTION_CODE_COUNT> optionRegisterSettings);
    ~GenericMuxedInterruptDistributor() override;
 
    void handle(VersionNumber version) override;
 
    void activate(VersionNumber version) override;
 
    static std::unique_ptr<GenericMuxedInterruptDistributor> create(std::string const& description, // THE JSON SNIPPET
        const boost::shared_ptr<SubDomain<std::nullptr_t>>& parent);
 
   protected:
    bool _ierIsReallyImaskr;
    bool _haveSieAndCie;
    bool _hasMer;
    uint32_t _activeInterrupts{0}; // like a local copy of IER
 
    boost::shared_ptr<NDRegisterAccessor<uint32_t>> _isr;
    boost::shared_ptr<NDRegisterAccessor<uint32_t>> _ier; // May point to IER or Imaskr
    boost::shared_ptr<NDRegisterAccessor<uint32_t>> _icr; // May point to ICR, IAR, or ISR, which act identically
    boost::shared_ptr<NDRegisterAccessor<uint32_t>> _mer; // May point to MER, MIE, or GIE, all act identically.
                                                          // We can have at most 1 of {MIE, GIE, MER}
    boost::shared_ptr<NDRegisterAccessor<uint32_t>> _sie; // We either have both SIE or CIE or neither.
    boost::shared_ptr<NDRegisterAccessor<uint32_t>> _cie;
 
    RegisterPath _path; // just a string path, with the added overwritten / operator etc.
 
    std::atomic<bool> _handlerRan{false};
 
    std::atomic<bool> _watchdogAlerted{false};
 
    std::thread _watchdogThread;
    std::atomic<bool> _stopWatchdog{false};
    static constexpr std::chrono::milliseconds _watchdogInterval{1000};
 
    void watchdogLoop();
 
    void clearInterruptsFromMask(uint32_t mask);
 
    inline void clearOneInterrupt(uint32_t ithInterrupt);
 
    inline void clearAllInterrupts();
 
    inline void clearAllEnabledInterrupts();
 
    void disableInterruptsFromMask(uint32_t mask);
 
    inline void disableOneInterrupt(uint32_t ithInterrupt);
 
    void enableInterruptsFromMask(uint32_t mask);
 
    inline void enableOneInterrupt(uint32_t ithInterrupt);
 
    void activateSubDomain(SubDomain<std::nullptr_t>& subDomain, VersionNumber const& version) override;
  };
 
} // namespace ChimeraTK::async