device_base.hpp

#if !defined(__DEVICE_BASE_HPP__)
#define __DEVICE_BASE_HPP__

//
// local includes
//
#include "core/machine/machine_base.hpp"
#include "device.hpp"

struct device_base : public iospace_handler, public mmio_handler, public irq_source,
                     public device, private noncopyable
{
    static const bool VERBOSE_ALLOCATION = false;

  protected:
    const string device_name;

    machine_base &machine;

    l4_irq_t irq;

  public:
    inline device_base(machine_base &machine, const string &device_name)
        : device_name(device_name), machine(machine), irq(irq_manager::NO_IRQ)
    {}

    //
    // iospace_handler: override read_ioport & write_ioport
    //
    virtual inline uint32_t read_ioport(l4_port_t port, access_size access_size)
    {
        log::debug("%s:\n  device_base::%s called. override?\n"
                   "  read %s at "l4_port_fmt"\n",
                   name(), __func__, access_size.string(), port);
        return iospace_handler::INVALID;
    }

    virtual inline int write_ioport(l4_port_t port, uint32_t data, access_size access_size)
    {
        log::debug("%s:\n  device_base::%s called. override?\n"
                   "  write %s %s at "l4_port_fmt"\n",
                   name(), __func__,
                   access_size.string(), format_hex<uint32_t>(data, access_size*2).c_str(), port);
        return -L4_ENOTSUPP;
    }

    //
    // mmio_handler: override read_mmio/write_mmio & I/O memory (un)map functions
    //
    virtual inline l4_umword_t read_mmio(l4_gpa_t address, access_size access_size)
    {
        log::debug("%s:\n  device_base::%s called. override?\n"
                   "  read %s at "l4_gpa_fmt"\n",
                   name(), __func__, access_size.string(), address);
        return mmio_handler::INVALID;
    }

    virtual inline int write_mmio(l4_gpa_t address, l4_umword_t data, access_size access_size)
    {
        log::debug("%s:\n  device_base::%s called. override?\n"
                   "  write %s %s at "l4_gpa_fmt"\n",
                   name(), __func__,
                   access_size.string(), format_hex<l4_umword_t>(data, access_size*2).c_str(), address);
        return -L4_ENOTSUPP;
    }

    virtual l4_hva_t map_mmio_region(int flags, l4_gpa_t base, l4_gpa_t size=1)
    {
        log::debug("%s:\n  device_base::%s called. override?\n"
                   "  "l4_gpa_fmt"-"l4_gpa_fmt" ["l4_gpa_fmt"]\n",
                   name(), __func__, base, base + size - 1, size);
        return 0;
    }

    virtual int unmap_mmio_region(l4_gpa_t base, l4_gpa_t size=1)
    {
        log::debug("%s:\n  device_base::%s called. override?\n"
                   "  "l4_gpa_fmt"-"l4_gpa_fmt" ["l4_gpa_fmt"]\n",
                   name(), __func__, base, base + size - 1, size);
        return -L4_ENOTSUPP;
    }

    //
    // irq_source: override irq_moved
    //
    virtual inline void irq_moved(l4_irq_t from, l4_irq_t to)
    {
        irq=to;
    }

    //
    // device: override name & reset
    //
    virtual inline const char *name(void) const
    {
        return device_name.c_str();
    }

    virtual int reset(void)
    {
        return 0;
    }

  protected:
    //
    // device helper functions
    //
    virtual inline int use_iospace(l4_port_t base, l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION)
    {
        return machine.register_iospace_handler(this, base, size, verbose);
    }

    virtual inline int change_iospace(iospace_manager::ioport_flags use, l4_port_t base,
                                      l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION)
    {
        return machine.change_iospace_region(this, use, base, size, verbose);
    }

    virtual inline int free_iospace(l4_port_t base, l4_port_t size=1, bool verbose=VERBOSE_ALLOCATION)
    {
        return machine.unregister_iospace_handler(this, base, size, verbose);
    }

    virtual inline int use_iomemory(l4_gpa_t base, l4_gpa_t size=1, bool verbose=VERBOSE_ALLOCATION)
    {
        return machine.register_mmio_handler(this, base, size, verbose);
    }

    virtual inline int free_iomemory(l4_gpa_t base, l4_gpa_t size=1, bool verbose=VERBOSE_ALLOCATION)
    {
        return machine.unregister_mmio_handler(this, base, size, verbose);
    }

    virtual inline int use_irq(irq_manager::irq_flags use=irq_manager::VIRTUAL,
                               l4_irq_t requested_irq=irq_manager::NO_IRQ,
                               l4_irq_t physical_irq=irq_manager::NO_IRQ,
                               bool verbose=VERBOSE_ALLOCATION)
    {
        const int ret=machine.register_irq(this, use, requested_irq, physical_irq, verbose);
        this->irq=(ret >= 0) ? ret : irq_manager::NO_IRQ;
        return ret;
    }

    inline void assert_irq(void) const
    {
        machine.assert_irq(irq);
    }

    virtual inline int free_irq(bool verbose=VERBOSE_ALLOCATION)
    {
        const int ret=machine.unregister_irq(this, irq, verbose);
        irq=irq_manager::NO_IRQ;
        return ret;
    }
};

#endif

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