devices.hpp

#if !defined(__DEVICES_HPP__)
#define __DEVICES_HPP__

//
// local includes
//
#include "core/common.hpp"

//
// forward declarations
//
struct config_node;
struct machine_base;

template <typename DeviceT=void>
struct device_descriptors
{
    typedef DeviceT device_type;
    typedef device_type *(*create_func_ptr)(machine_base &, config_node &);
    typedef int (*multi_create_func_ptr)(vector<device_type *> &, machine_base &, config_node &);

    enum flags_constants
    {
        SINGLETON = 0x01,
        ALL_MASK  = SINGLETON
    };

    typedef bitmask<typename uint_value_t<ALL_MASK | L4VMM_ALL_MASK>::least> flags;

    static_assert(integer_traits<typename flags::word_type>::const_max >= (ALL_MASK | L4VMM_ALL_MASK),
                  "flags's max value is too small");

    struct descriptor
    {
        create_func_ptr create_func;

        multi_create_func_ptr multi_create_func;

        flags device_flags,

              l4vmm_flags;

        inline descriptor(void)
            : create_func(nullptr), multi_create_func(nullptr),
              device_flags(0), l4vmm_flags(0)
        {}

        inline descriptor(const create_func_ptr create_func,
                          const multi_create_func_ptr multi_create_func,
                          const flags device_flags, const flags l4vmm_flags)
            : create_func(create_func), multi_create_func(multi_create_func),
              device_flags(device_flags), l4vmm_flags(l4vmm_flags)
        {}

        int update(const descriptor &other);
    };

    typedef map<string, descriptor> collection_type;

  protected:
    static device_descriptors &instance;

    collection_type descriptors;

  public:
    static inline const descriptor *get(const string &name)
    {
        typename collection_type::const_iterator it=instance.descriptors.find(name);
        return (it != endof(instance.descriptors)) ? &it->second : nullptr;
    }

    static int register_device(const string &name, const descriptor &descriptor);
    static void print(const char *header=nullptr);
};

//
// extern template declarations to prevent implicit instantiations
//
extern template struct device_descriptors<>;
extern template struct device_descriptors<struct device>;
extern template struct device_descriptors<struct pci_device>;

//
// dummy struct to execute code to register devices (if linked at all)
//     during library initialization. used with the appropriate init priority.
//
template <typename DeviceT>
struct register_device
{
    typedef device_descriptors<DeviceT> descriptors_type;
    typedef typename descriptors_type::descriptor descriptor_type;

    inline register_device(const char *name,
                           const typename descriptors_type::create_func_ptr create_func,
                           const typename descriptors_type::flags device_flags=0,
                           const typename descriptors_type::flags l4vmm_flags=0)
    {
        descriptors_type::register_device(name, descriptor_type(create_func, nullptr,
                                                                device_flags, l4vmm_flags));
    }

    inline register_device(const char *name,
                           const typename descriptors_type::multi_create_func_ptr multi_create_func,
                           const typename descriptors_type::flags device_flags=0,
                           const typename descriptors_type::flags l4vmm_flags=0)
    {
        descriptors_type::register_device(name, descriptor_type(nullptr, multi_create_func,
                                                                device_flags, l4vmm_flags));
    }
};

//
// register macros to be used in device implementations
//
#if (__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ <= 3)
    //
    // FIXME: GCC3
    // special version for GCC 3.3, which cannot handle attributes before
    //     variable declaration ...
    //
    #define __REGISTER_DEVICE(device_type, name, args...)               \
        static const register_device<device_type>                       \
            register_ ## name ## _device(L4_stringify(name), args)      \
                __attribute__((__used__, __init_priority__(2000)));
#elif defined(__GNUC__)
    //
    // ... while newer versions really need it there. hmm.
    //
    #define __REGISTER_DEVICE(device_type, name, args...)               \
        static const register_device<device_type>                       \
            __attribute__((__used__, __init_priority__(2000)))          \
                register_ ## name ## _device(L4_stringify(name), args);
#else
    #error define __REGISTER_DEVICE for your compiler first
#endif

#define REGISTER_DEVICE(name, args...)      __REGISTER_DEVICE(device, name, args)
#define REGISTER_PCI_DEVICE(name, args...)  __REGISTER_DEVICE(pci_device, name, args)

#endif

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