Program Listing for File register_device_interface.hpp

↰ Return to documentation for file (register_device_interface.hpp)

#ifndef REGISTER_DEVICE_MANAGER_H_
#define REGISTER_DEVICE_MANAGER_H_

#include <memory>
#include <stdint.h>
#include <string>
#include <format>

#include "ers/ers.h"

#include "device.hpp"
#include "regmap_manager.hpp"


ERS_DECLARE_ISSUE(felix_log, register_device_interface_issue, issue_message, ((const std::string&)issue_message))


template <class DEV>
class RegisterDeviceInterface
{
public:

    RegisterDeviceInterface(RegmapManager & registermap, std::shared_ptr<DEV> main, std::shared_ptr<DEV> primary)
        : m_regmap(registermap), m_main(main), m_primary(primary){}

    uint64_t get_register(const std::string& reg_name);

    void set_register(const std::string& reg_name, uint64_t value);

    bool can_read(const std::string& reg_name){ return m_regmap.can_read(reg_name); };

    bool can_write(const std::string& reg_name){ return m_regmap.can_write(reg_name); };

private:
    RegmapManager & m_regmap;
    std::shared_ptr<DEV> m_main;
    std::shared_ptr<DEV> m_primary;

    DEV* select_device(const std::string& reg_name);
};


template <class DEV>
DEV* RegisterDeviceInterface<DEV>::select_device(const std::string& reg_name)
{
    DEV* device = nullptr;
    unsigned dev_no = m_main->get_device_number();

    if (not m_regmap.has_endpoint_1(reg_name) and not m_main->is_primary())
    {
        if (!m_primary.get()){
            ers::error(felix_log::register_device_interface_issue(ERS_HERE, std::format("Cannot access register {}. Primary endpoint for device {} not initialized", reg_name, dev_no)));
        }
        else if (!m_primary->is_primary()) {
            unsigned primary_dev_no = m_primary->get_device_number();
            ers::error(felix_log::register_device_interface_issue(ERS_HERE, std::format("Cannot access register {}. Neither devices {} and {} are primary", reg_name, dev_no, primary_dev_no)));
        } else {
            device = m_primary.get();
        }
    } else {
        device = m_main.get();
        if (!device){
            ers::error(felix_log::register_device_interface_issue(ERS_HERE, std::format("Cannot access register {}. Device {} not initialized", reg_name, dev_no)));
        }
    }
    return device;
}


template <class DEV>
uint64_t RegisterDeviceInterface<DEV>::get_register(const std::string& reg_name)
{
    DEV* device = select_device(reg_name);
    if (device) {
        return device->get_register(reg_name.c_str());
    }
    return 0;
}


template <class DEV>
void RegisterDeviceInterface<DEV>::set_register(const std::string& reg_name, uint64_t value)
{
    DEV* device = select_device(reg_name);
    if (device) {
        device->set_register(reg_name.c_str(), value);
    }
}

#endif /* REGISTER_DEVICE_MANAGER_H_ */