iospace_manager.hpp

#if !defined(__IOSPACE_MANAGER_HPP__)
#define __IOSPACE_MANAGER_HPP__

//
// local includes
//
#include "core/machine/generic/resource_manager.hpp"
#include "iospace_default_handler.hpp"

//
// forward declarations
//
struct machine_config;

struct iospace_manager : public resource_manager, private noncopyable
{
    static const bool VERBOSE_ALLOCATION = false;
    static const int  NUM_IOPORTS        = L4_IOPORT_MAX;

    //
    //     l4_port_t must be unsigned. ports below 0 don't exist.
    //
    static_assert(is_unsigned<l4_port_t>::conforms, "l4_port_t must be an unsigned integer");
    static_assert(static_cast<uint32_t>(integer_traits<l4_port_t>::const_max) >= NUM_IOPORTS - 1,
                  "l4_port_t's max value is too small");

    typedef resource_flags ioport_flags;

    struct ioport_state : public ioport_flags
    {
        iospace_handler *handler;

        inline ioport_state(void)
            : ioport_flags(0), handler(nullptr)
        {}

        friend inline bool operator ==(const ioport_state &s1, const ioport_state &s2)
        {
            return (s1.bits == s2.bits) && (s1.handler == s2.handler);
        }
    };

  protected:
    const machine_config &config;

    lock iospace_lock;

    ioport_state iospace_state[NUM_IOPORTS];

    iospace_default_handler default_handler;

  public:
    //
    // constructors & destructors
    //
    iospace_manager(const machine_config &config);
    virtual ~iospace_manager(void);

    virtual int check_iospace_request(const iospace_handler *handler, l4_port_t base,
                                      l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION) const;

    //
    // virtual I/O space management functions
    //
    virtual int register_iospace_handler(iospace_handler *handler, l4_port_t base,
                                         l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION);
    virtual int unregister_iospace_handler(const iospace_handler *handler, l4_port_t base,
                                           l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION);

    inline bool is_ioport_virtual(const l4_port_t port) const
    {
        assert_logd(L4VMM_DEBUG_IOSPACE, is_valid_ioport(port), "port: "l4_port_fmt"\n", port);
        return iospace_state[port].is_virtual();
    }

    //
    // virtual I/O port access proxy functions
    //
    template <typename WordT>
    inline WordT read_virtual_ioport(const l4_port_t port)
    {
        static_assert((is_integer<WordT, 1, 4>::conforms), "WordT must be an integer of at most (un)signed int");
        assert_logd(L4VMM_DEBUG_IOSPACE, is_valid_ioport(port), "port: "l4_port_fmt"\n", port);
        assert_logd(L4VMM_DEBUG_IOSPACE, iospace_state[port].handler != nullptr, "port: "l4_port_fmt"\n", port);
        return iospace_state[port].handler->read_ioport(port, sizeof(WordT));
    }

    template <typename WordT>
    inline int write_virtual_ioport(const l4_port_t port, const WordT data)
    {
        static_assert((is_integer<WordT, 1, 4>::conforms), "WordT must be an integer of at most (un)signed int");
        assert_logd(L4VMM_DEBUG_IOSPACE, is_valid_ioport(port), "port: "l4_port_fmt"\n", port);
        assert_logd(L4VMM_DEBUG_IOSPACE, iospace_state[port].handler != nullptr, "port: "l4_port_fmt"\n", port);
        return iospace_state[port].handler->write_ioport(port, data, sizeof(WordT));
    }

    //
    // physical I/O space management functions
    //
    virtual int request_iospace_region(iospace_handler *handler, l4_port_t base,
                                       l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION);
    virtual int release_iospace_region(const iospace_handler *handler, l4_port_t base,
                                       l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION);
    virtual int release_iospace_regions(const iospace_handler *handler=nullptr,
                                        bool verbose=VERBOSE_ALLOCATION);

    inline bool is_ioport_physical(const l4_port_t port) const
    {
        assert_logd(L4VMM_DEBUG_IOSPACE, is_valid_ioport(port), "port: "l4_port_fmt"\n", port);
        return iospace_state[port].is_physical();
    }

    //
    // other functions
    //
    virtual int check_iospace_use(ioport_flags use, l4_port_t base, l4_port_t size=1);
    virtual int change_iospace_region(iospace_handler *handler, ioport_flags use, l4_port_t base,
                                      l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION);

    // TODO: should be removed
    inline iospace_handler *get_ioport_handler(const l4_port_t port) const
    {
        assert_logd(L4VMM_DEBUG_IOSPACE, is_valid_ioport(port), "port: "l4_port_fmt"\n", port);
        return iospace_state[port].handler;
    }

    //
    // debug stuff
    //
    virtual void print_iospace_state(const char *header=nullptr);

  protected:
    virtual int init_iospace(void);

  public:
    static inline bool is_valid_ioport(const l4_port_t port)
    {
        return range_traits<l4_port_t, NUM_IOPORTS>::is_valid(port);
    }
};

#endif

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