dma_space

Go to the documentation of this file.

// -*- Mode: C++ -*-
// vim:ft=cpp
/*
 * (c) 2014 Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
 
#pragma once
 
#include <l4/sys/types.h>
#include <l4/sys/l4int.h>
#include <l4/sys/capability>
#include <l4/re/dataspace>
#include <l4/re/protocols.h>
#include <l4/sys/cxx/types>
#include <l4/sys/cxx/ipc_types>
#include <l4/sys/cxx/ipc_iface>
 
namespace L4Re
{
 

class Dma_space :
  public L4::Kobject_0t< Dma_space,
                         L4RE_PROTO_DMA_SPACE,
                         L4::Type_info::Demand_t<1> >
{
public:
  typedef l4_uint64_t Dma_addr;
  typedef l4_uint64_t Dma_size;

  enum Direction
  {
    Bidirectional, 
    To_device,     
    From_device,   
    None           
  };

  enum Attribute : unsigned
  {
    Search_addr = 1U << 0,

    Partial_map = 1U << 1,

    Reserve = 1U << 2,

    Replace = 1U << 3,
  };
 
  friend void enum_bitops_enable(Attribute);

  using Attributes = L4::Types::Flags_t<Attribute, unsigned>;

  l4_ret_t map(L4::Ipc::Cap<L4Re::Dataspace> src,
               L4Re::Dataspace::Offset offset,
               l4_size_t * size,
               Attributes attrs, Direction dir,
               Dma_addr *dma_addr)
  {
    static_cast<void>(dir);
 
    Dma_addr a = 0;
    Dma_size sz = *size;
 
    l4_ret_t ret = map(src, offset, &sz, &a, -1, attrs | Search_addr);
    if (ret >= 0)
      {
        *dma_addr = a;
        *size = sz;
      }
 
    return ret;
  }

  l4_ret_t map(L4::Ipc::Cap<L4Re::Dataspace> src,
               L4Re::Dataspace::Offset offset,
               Dma_size *size,
               Dma_addr *dma_addr,
               Dma_addr dma_max = -1,
               Attributes attrs = Search_addr,
               unsigned char align = L4_SUPERPAGESHIFT)
  {
    return map_t::call(c(), src, offset, size, align, attrs, dma_addr, dma_max);
  }
 
  L4_RPC_NF(
      l4_ret_t, map, (L4::Ipc::Opt<L4::Ipc::Cap<L4Re::Dataspace>> src,
                      L4Re::Dataspace::Offset offset,
                      L4::Ipc::In_out<Dma_size *> size, unsigned char align,
                      Attributes attrs, L4::Ipc::In_out<Dma_addr *> dma_addr,
                      Dma_addr dma_max));

  enum Unmap_flag : unsigned
  {
    Cancel_reservation = 1U << 0,
  };
 
  friend void enum_bitops_enable(Unmap_flag);

  using Unmap_flags = L4::Types::Flags_t<Unmap_flag, unsigned>;

  l4_ret_t unmap(Dma_addr dma_addr, Dma_size size, Attributes attrs,
                 Direction dir)
  {
    static_cast<void>(attrs);
    static_cast<void>(dir);
    return unmap(dma_addr, size);
  }

  l4_ret_t unmap(Dma_addr dma_addr, Dma_size size,
                 Unmap_flags flags = Unmap_flags())
  {
    return unmap_t::call(c(), dma_addr, size, flags);
  }
 
  L4_RPC_NF(l4_ret_t, unmap, (Dma_addr dma_addr, Dma_size size,
                              Unmap_flags flags));
 
  typedef L4::Typeid::Rpcs<map_t, unmap_t> Rpcs;
};

class Dma_space_mgr :
  public L4::Kobject_0t< Dma_space_mgr, L4::PROTO_ANY,
                         L4::Type_info::Demand_t<2> >
{
public:
  using Dma_addr = Dma_space::Dma_addr;
  using Dma_size = Dma_space::Dma_size;

  enum Space_attrib : unsigned
  {
    Identity_map = 1U << 0,
  };
 
  friend void enum_bitops_enable(Space_attrib);

  using Space_attribs = L4::Types::Flags_t<Space_attrib, unsigned>;

  enum Block_flag : unsigned
  {
    Search_addr = 1U << 0,
  };
 
  friend void enum_bitops_enable(Block_flag);

  using Block_flags = L4::Types::Flags_t<Block_flag, unsigned>;

  L4_INLINE_RPC(
      l4_ret_t, associate, (L4::Ipc::Cap<Dma_space> dma_space,
                            L4::Ipc::Cap<L4::Task> dma_task,
                            Space_attribs attr));

  L4_INLINE_RPC(
      l4_ret_t, associate_phys, (L4::Ipc::Cap<Dma_space> dma_space,
                                 Space_attribs attr));

  L4_INLINE_RPC(
      l4_ret_t, disassociate, (L4::Ipc::Cap<Dma_space> dma_space));

  l4_ret_t block_area(L4::Ipc::Cap<Dma_space>     dma_space,
                      L4::Ipc::In_out<Dma_addr *> addr,
                      Dma_size                    size,
                      Dma_addr                    max_addr = -1,
                      Block_flags                 flags = Block_flags(),
                      unsigned char               align = L4_SUPERPAGESHIFT)
  {
    return block_area_t::call(c(), dma_space, addr, size, max_addr, flags,
                              align);
  }
 
  L4_RPC_NF(
      l4_ret_t, block_area, (L4::Ipc::Cap<Dma_space>      dma_space,
                             L4::Ipc::In_out<Dma_addr *>  addr,
                             Dma_size                     size,
                             Dma_addr                     max_addr,
                             Block_flags                  flags,
                             unsigned char                align));

  L4_INLINE_RPC(
      l4_ret_t, set_limits, (L4::Ipc::Cap<Dma_space> dma_space,
                             Dma_addr min_addr,
                             Dma_addr max_addr));
 
 
  typedef L4::Typeid::Rpcs<associate_t, associate_phys_t, disassociate_t,
                           block_area_t, set_limits_t> Rpcs;
};
 
}