l4virtio

// vi:set ft=cpp: -*- Mode: C++ -*-
/* SPDX-License-Identifier: MIT */
/*
 * Copyright (C) 2013-2022 Kernkonzept GmbH.
 * Author(s): Alexander Warg <alexander.warg@kernkonzept.com>
 *            Matthias Lange <matthias.lange@kernkonzept.com>
 *
 */
#pragma once
 
#include "virtio.h"
#include <l4/sys/capability>
#include <l4/sys/cxx/ipc_client>
#include <l4/re/dataspace>
#include <l4/sys/irq>
#include <l4/cxx/utils>
 
namespace L4virtio {
class Device :
  public L4::Kobject_t<Device, L4::Icu, L4VIRTIO_PROTOCOL,
                       L4::Type_info::Demand_t<1> >
{
public:
  typedef l4virtio_config_queue_t Config_queue;
  struct Config_hdr : l4virtio_config_hdr_t
  {
    Config_queue *queues() const
    { return l4virtio_config_queues(this); }
 
    template <typename T>
    T *device_config() const
    {
      return static_cast<T*>(l4virtio_device_config(this));
    }
 
    int config_queue(unsigned num, L4::Cap<L4::Triggerable> out_notify,
                     L4::Cap<L4::Triggerable> in_notify,
                     l4_timeout_s to = L4_IPC_TIMEOUT_NEVER)
    {
      return send_cmd(L4VIRTIO_CMD_CFG_QUEUE | num,
                      out_notify, in_notify, to);
    }
 
    int notify_queue(unsigned num, L4::Cap<L4::Triggerable> out_notify,
                     L4::Cap<L4::Triggerable> in_notify,
                     l4_timeout_s to = L4_IPC_TIMEOUT_NEVER)
    {
      return send_cmd(L4VIRTIO_CMD_NOTIFY_QUEUE | num,
                      out_notify, in_notify, to);
    }
 
    bool fail_state() const
    {
      auto cfg_status = cxx::access_once(&status);
      return cfg_status
             & (L4VIRTIO_STATUS_FAILED | L4VIRTIO_STATUS_DEVICE_NEEDS_RESET);
    }
 
    int set_status(unsigned new_status, L4::Cap<L4::Triggerable> out_notify,
                   L4::Cap<L4::Triggerable> in_notify,
                   l4_timeout_s to = L4_IPC_TIMEOUT_NEVER)
    {
      return send_cmd(L4VIRTIO_CMD_SET_STATUS | new_status,
                      out_notify, in_notify, to);
    }
 
    int cfg_changed(unsigned reg, L4::Cap<L4::Triggerable> out_notify,
                   L4::Cap<L4::Triggerable> in_notify,
                   l4_timeout_s to = L4_IPC_TIMEOUT_NEVER)
    {
      return send_cmd(L4VIRTIO_CMD_CFG_CHANGED | reg,
                      out_notify, in_notify, to);
    }
 
    int send_cmd(unsigned command, L4::Cap<L4::Triggerable> out_notify,
                 L4::Cap<L4::Triggerable> in_notify,
                 l4_timeout_s to = L4_IPC_TIMEOUT_NEVER)
    {
      cxx::write_now(&cmd, command);
 
      if (out_notify)
        out_notify->trigger();
 
      auto utcb = l4_utcb();
      auto ipc_to = l4_timeout(L4_IPC_TIMEOUT_0, to);
 
      do
        {
          if (in_notify)
            if (l4_ipc_error(l4_ipc_receive(in_notify.cap(), utcb, ipc_to),
                             utcb) == L4_IPC_RETIMEOUT)
              break;
        }
      while (cxx::access_once(&cmd));
 
      return cxx::access_once(&cmd) ? -L4_EBUSY : L4_EOK;
    }
  };
 
  L4_INLINE_RPC_OP(L4VIRTIO_OP_SET_STATUS, long,
                   set_status, (unsigned status));
 
  L4_INLINE_RPC_OP(L4VIRTIO_OP_CONFIG_QUEUE, long,
                   config_queue, (unsigned queue));
 
  L4_INLINE_RPC_OP(L4VIRTIO_OP_REGISTER_DS, long,
                   register_ds, (L4::Ipc::Cap<L4Re::Dataspace> ds_cap,
                                 l4_uint64_t base, l4_umword_t offset,
                                 l4_umword_t size));
 
  L4_INLINE_RPC_OP(L4VIRTIO_OP_DEVICE_CONFIG, long, device_config,
                   (L4::Ipc::Out<L4::Cap<L4Re::Dataspace> > config_ds,
                    l4_addr_t *ds_offset));
 
  L4_INLINE_RPC_OP(L4VIRTIO_OP_GET_DEVICE_IRQ, long, device_notification_irq,
                   (unsigned index, L4::Ipc::Out<L4::Cap<L4::Triggerable> > irq));
 
 
  typedef L4::Typeid::Rpcs<set_status_t, config_queue_t, register_ds_t,
                           device_config_t, device_notification_irq_t>
    Rpcs;
};
 
}