vbus

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2011 Adam Lackorzynski <adam@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 */
#pragma once
 
#include <l4/vbus/vbus.h>
#include <l4/vbus/vbus_pm.h>
#include <l4/sys/icu>
 
#include <l4/re/dataspace>
#include <l4/re/dma_space>
#include <l4/re/event>
#include <l4/re/inhibitor>
 
namespace L4vbus {
 
class Vbus;
 
template<typename DEC>
class Pm
{
private:
  DEC const *self() const { return static_cast<DEC const *>(this); }
  DEC *self() { return static_cast<DEC *>(this); }
public:
  int pm_suspend() const
  { return l4vbus_pm_suspend(self()->bus_cap().cap(), self()->dev_handle()); }
 
  int pm_resume() const
  { return l4vbus_pm_resume(self()->bus_cap().cap(), self()->dev_handle()); }
};
 
 
class Device : public Pm<Device>
{
public:
  Device() : _dev(L4VBUS_NULL) {}
 
  Device(L4::Cap<Vbus> bus, l4vbus_device_handle_t dev)
  : _bus(bus), _dev(dev) {}
 
  L4::Cap<Vbus> bus_cap() const { return _bus; }
 
  l4vbus_device_handle_t dev_handle() const { return _dev; }
 
 
  int device_by_hid(Device *child, char const *hid,
                    int depth = L4VBUS_MAX_DEPTH,
                    l4vbus_device_t *devinfo = 0) const
  {
    child->_bus = _bus;
    return l4vbus_get_device_by_hid(_bus.cap(), _dev, &child->_dev, hid,
                                    depth, devinfo);
  }
 
  int next_device(Device *child, int depth = L4VBUS_MAX_DEPTH,
                  l4vbus_device_t *devinfo = 0) const
  {
    child->_bus = _bus;
    return l4vbus_get_next_device(_bus.cap(), _dev, &child->_dev, depth,
                                  devinfo);
  }
 
  int device(l4vbus_device_t *devinfo) const
  { return l4vbus_get_device(_bus.cap(), _dev, devinfo); }
 
  int get_resource(unsigned res_idx, l4vbus_resource_t *res) const
  {
    return l4vbus_get_resource(_bus.cap(), _dev, res_idx, res);
  }
 
  int is_compatible(char const *cid) const
  { return l4vbus_is_compatible(_bus.cap(), _dev, cid); }
 
  bool operator == (Device const &o) const
  {
    return _bus == o._bus && _dev == o._dev;
  }
 
  bool operator != (Device const &o) const
  {
    return _bus != o._bus || _dev != o._dev;
  }
 
protected:
  L4::Cap<Vbus> _bus;          
  l4vbus_device_handle_t _dev; 
};
 
class Icu : public Device
{
public:
  enum Src_types
  {
    Src_dev_handle = L4VBUS_ICU_SRC_DEV_HANDLE
  };
 
  int vicu(L4::Cap<L4::Icu> icu) const
  {
    return l4vbus_vicu_get_cap(_bus.cap(), _dev, icu.cap());
  }
};
 
class Vbus : public L4::Kobject_3t<Vbus, L4Re::Dataspace, L4Re::Inhibitor, L4Re::Event>
{
public:
 
  int request_ioport(l4vbus_resource_t *res) const
  {
    return l4vbus_request_ioport(cap(), res);
  }
 
  int release_ioport(l4vbus_resource_t *res) const
  {
    return l4vbus_release_ioport(cap(), res);
  }
 
  Device root() const
  {
    return Device(L4::Cap<Vbus>(cap()), L4VBUS_ROOT_BUS);
  }
 
  int assign_dma_domain(unsigned domain_id, unsigned flags,
                        L4::Cap<L4Re::Dma_space> dma_space) const
  {
    flags |= L4VBUS_DMAD_L4RE_DMA_SPACE;
    flags &= ~L4VBUS_DMAD_KERNEL_DMA_SPACE;
    return l4vbus_assign_dma_domain(cap(), domain_id, flags, dma_space.cap());
  }
 
  int assign_dma_domain(unsigned domain_id, unsigned flags,
                        L4::Cap<L4::Task> dma_space) const
  {
    flags |= L4VBUS_DMAD_KERNEL_DMA_SPACE;
    flags &= ~L4VBUS_DMAD_L4RE_DMA_SPACE;
    return l4vbus_assign_dma_domain(cap(), domain_id, flags, dma_space.cap());
  }
 
  typedef L4::Typeid::Raw_ipc<Vbus> Rpcs;
};
 
} // namespace L4vbus