decoders.h

#ifndef DECODERS_H
#define DECODERS_H
 
#include <cstdint>
#include <cstdio>
#include <memory>
#include <optional>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
#include <sys/types.h>
 
#include "sdb-defs.h"
 
#define LNLS_VENDORID 0x1000000000001215
 
struct RegisterDecoderPrivate;
class Printer;
 
#define CONSTRUCTOR_REGS(type) regs_storage(new type()), regs(*regs_storage)
 
namespace decoders {
using data_type = std::variant<std::int32_t, double>;
 
using data_key = std::pair<std::string_view, std::optional<unsigned>>;
}
 
class RegisterDecoderBase {
    bool devinfo_is_set = false;
 
    uint64_t vendor_id;
    uint32_t device_id;
    uint8_t major_version;
    bool check_devinfo = false;
 
    bool match_devinfo(const struct sdb_device_info &) const;
 
protected:
    size_t read_size;
    void *read_dest;
 
    void set_read_dest(auto &dest)
    {
        read_dest = &dest;
        read_size = sizeof dest;
    }
 
    struct pcie_bars &bars;
    struct sdb_device_info devinfo;
    size_t addr;
 
    RegisterDecoderBase(struct pcie_bars &, const struct sdb_device_info &);
 
    virtual void read();
 
public:
    void check_devinfo_is_set() const;
    virtual void set_devinfo(const struct sdb_device_info &);
 
    const device_match_fn match_devinfo_lambda;
};
 
struct RegisterField {
    decoders::data_type value;
    size_t offset;
    uint32_t mask;
    unsigned fixed_point_pos = 0;
    bool multibit;
    bool is_signed;
    bool is_fixed_point = false;
};
 
class RegisterDecoder : public RegisterDecoderBase {
    bool is_boolean_value(const char *) const;
    int32_t try_boolean_value(const char *, int32_t) const;
 
    std::unique_ptr<RegisterDecoderPrivate> pvt;
 
    template <class T>
    void add_data_internal(const char *, decoders::data_key::second_type, T);
 
    void rf_add_data_internal(
        const char *, decoders::data_key::second_type, RegisterField);
 
    size_t register2offset(uint32_t *);
    uint32_t *offset2register(size_t, void *);
 
    void write_internal(
        const char *, std::optional<unsigned>, decoders::data_type, void *);
 
protected:
    std::optional<unsigned> number_of_channels;
 
    std::unordered_map<std::string_view, Printer> printers;
 
    RegisterDecoder(struct pcie_bars &, const struct sdb_device_info &,
        std::unordered_map<std::string_view, Printer>);
 
    void add_general(const char *, int32_t);
    void add_general_double(const char *, double);
    void add_channel(const char *, unsigned, int32_t);
    void add_channel_double(const char *, unsigned, double);
 
    RegisterField rf_get_bit(uint32_t &, uint32_t);
    RegisterField rf_extract_value(uint32_t &, uint32_t, bool = false);
    RegisterField rf_whole_register(uint32_t &value, bool is_signed = false)
    {
        return rf_extract_value(value, UINT32_MAX, is_signed);
    }
    RegisterField rf_fixed2float(RegisterField, unsigned);
 
    inline void add_general(const char *name, RegisterField rf)
    {
        rf_add_data_internal(name, std::nullopt, rf);
    }
    inline void add_channel(const char *name, unsigned pos, RegisterField rf)
    {
        rf_add_data_internal(name, pos, rf);
    }
 
    virtual void read_monitors();
    virtual void decode() = 0;
    virtual void decode_monitors();
 
public:
    virtual ~RegisterDecoder();
    void get_data(bool = false);
    void binary_dump(FILE *) const;
    virtual void print(FILE *, bool) const;
 
    template <class T> T get_general_data(const char *name) const
    {
        return std::get<T>(get_generic_data(name));
    }
    template <class T>
    T get_channel_data(const char *name, unsigned channel_index) const
    {
        return std::get<T>(get_generic_data(name, channel_index));
    }
 
    decoders::data_type get_generic_data(
        const char *, decoders::data_key::second_type = std::nullopt) const;
 
    std::optional<unsigned> channel;
 
    inline void write_general(
        const char *name, decoders::data_type value, void *dest)
    {
        write_internal(name, std::nullopt, value, dest);
    }
    inline void write_channel(
        const char *name, unsigned pos, decoders::data_type value, void *dest)
    {
        write_internal(name, pos, value, dest);
    }
};
 
#endif