pci_ioregion.hpp

#if !defined(__PCI_IOREGION_HPP__)
#define __PCI_IOREGION_HPP__

//
// local includes
//
#include "core/machine/generic/resource_region.hpp"
#include "pci_config_header64.hpp"

struct pci_ioregion : public resource_region<l4_gpa_t>
{
    typedef resource_region<l4_gpa_t> super_type;

    enum type
    {
        UNUSED        = 0x00,
        IOSPACE       = 0x01,
        MEM           = 0x02,
        MEM_PREFETCH  = 0x04,
        ROM           = 0x08,

        IOMEMORY      = MEM | MEM_PREFETCH | ROM,
        ALL_MASK      = UNUSED | IOSPACE | MEM | MEM_PREFETCH | ROM | IOMEMORY
    } type;

    l4_hva_t virtual_base;

    //
    // constructors
    //
    inline pci_ioregion(void)
        : type(UNUSED), virtual_base(0)
    {}

    inline pci_ioregion(const enum type type, const l4_gpa_t base, const l4_gpa_t size,
                        const l4_hva_t virtual_base=0)
        : super_type(base, size), type(type), virtual_base(virtual_base)
    {}

    inline pci_ioregion(const union pci_config_header64::base_address &reg,
                        const l4_gpa_t size, const l4_hva_t virtual_base=0)
        : super_type(reg.region_base(), size),
          type(reg.iospace.indicator ? IOSPACE : reg.memory.prefetchable ? MEM_PREFETCH : MEM),
          virtual_base(virtual_base)
    {}

    inline pci_ioregion(const union pci_config_header64::expansion_ROM_address &reg,
                        const l4_gpa_t size, const l4_hva_t virtual_base)
        : super_type(reg.region_base(), size), type(ROM), virtual_base(virtual_base)
    {}

    //
    // set functions
    //
    inline pci_ioregion &operator ()(const enum type type, const l4_gpa_t base,
                                     const l4_gpa_t size, const l4_hva_t virtual_base=0)
    {
        this->type=type;
        this->base=base;
        this->size=size;
        this->virtual_base=virtual_base;
        return *this;
    }

    inline pci_ioregion &operator ()(const union pci_config_header64::base_address &reg,
                                     const l4_gpa_t size, const l4_hva_t virtual_base=0)
    {
        return (*this)(reg.iospace.indicator ? IOSPACE : reg.memory.prefetchable ? MEM_PREFETCH : MEM,
                       reg.region_base(), size, virtual_base);
    }

    inline pci_ioregion &operator ()(const union pci_config_header64::expansion_ROM_address &reg,
                                     const l4_gpa_t size, const l4_hva_t virtual_base)
    {
        return (*this)(ROM, reg.region_base(), size, virtual_base);
    }

    inline pci_ioregion &reset(void)
    {
        base=0;
        return *this;
    }

    //
    // query functions
    //
    inline bool is(const enum type type) const
    {
        return (this->type & type) != 0;
    }

    inline bool is_iospace(void) const
    {
        return is(IOSPACE);
    }

    inline bool is_iomemory(void) const
    {
        return is(IOMEMORY);
    }

    inline bool is_located(void) const
    {
        return base != 0;
    }

    inline bool is_used(void) const
    {
        return (type != UNUSED) && (size != 0);
    }

    inline l4_gpa_t size_mask(void) const
    {
        return ~(static_cast<l4_gpa_t>(size) - 1);
    }

    //
    // address register functions
    //
    template <typename WordT>
    static inline WordT register_value(const enum type type, const WordT value)
    {
        static_assert(is_integer<WordT>::conforms, "WordT must be an integer");
        return (type == IOSPACE) ? (value & ~0x03) | 0x01 :
                   (type == MEM) ? (value & ~0x0f) | 0x00 :
                       (type == MEM_PREFETCH) ? (value & ~0x0f) | 0x08 :
                           (type == ROM) ? (value & ~0x07ff) | 0x01 :
                               0x00;
    }

    template <typename WordT>
    inline WordT base2bar(void) const
    {
        return register_value<WordT>(type, base);
    }

    template <typename WordT>
    inline WordT size2bar(void) const
    {
        return register_value<WordT>(type, size_mask());
    }

    inline operator l4_umword_t(void) const
    {
        //
        // no template: doesn't work with le_uint32_t because of missing constructor
        //     when assigning the argument base (l4_gpa_t) in base2bar
        //
        return base2bar<l4_umword_t>();
    }

    //
    // debug stuff
    //
    static inline const char *type2string(const enum type type)
    {
        return (type == UNUSED) ? "unused" :
                   (type == IOSPACE) ? "ports" :
                       (type == MEM) ? "memory" :
                           (type == MEM_PREFETCH) ? "pref. memory" :
                               (type == ROM) ? "ROM" :
                                   (type == IOMEMORY) ? "any memory type" :
                                       (type == ALL_MASK) ? "any region type" : "unknown";
    }

    inline const char *type2string(void) const
    {
        return type2string(type);
    }

    inline int print(const char *prefix="", const char *suffix="") const
    {
        return is_iospace() ?
            log::print("%s"l4_port_fmt"-"l4_port_fmt" ["l4_port_fmt"] type: %s%s",
                       prefix,
                       static_cast<l4_port_t>(base),
                       static_cast<l4_port_t>(base + size - 1),
                       static_cast<l4_port_t>(size),
                       type2string(), suffix) :
            log::print("%s"l4_gpa_fmt"-"l4_gpa_fmt" ["l4_gpa_fmt"] type: %s%s",
                       prefix, base, base + size -1, size, type2string(), suffix);
    }

    inline int print_short(const char *prefix="", const char *suffix="") const
    {
        return is_iospace() ?
            log::print("%s"l4_port_fmt" ["l4_port_fmt"] type: %s%s",
                       prefix,
                       static_cast<l4_port_t>(base),
                       static_cast<l4_port_t>(size),
                       type2string(), suffix) :
            log::print("%s"l4_gpa_fmt" ["l4_gpa_fmt"] type: %s%s",
                       prefix, base, size, type2string(), suffix);
    }
};

#endif

// ***** end of source ***** //