l4virtio

// vi:ft=cpp
/* SPDX-License-Identifier: GPL-2.0-only or License-Ref-kk-custom */
/*
 * Copyright (C) 2015-2020, 2022 Kernkonzept GmbH.
 * Author(s): Sarah Hoffmann <sarah.hoffmann@kernkonzept.com>
 *
 */
#pragma once
 
#include <l4/sys/factory>
#include <l4/sys/semaphore>
#include <l4/re/dataspace>
#include <l4/re/env>
#include <l4/re/util/unique_cap>
#include <l4/re/util/object_registry>
#include <l4/re/error_helper>
 
#include <l4/util/atomic.h>
#include <l4/util/bitops.h>
#include <l4/l4virtio/l4virtio>
#include <l4/l4virtio/virtqueue>
#include <l4/sys/consts.h>
 
#include <cstring>
 
namespace L4virtio { namespace Driver {
 
class Device
{
public:
  void driver_connect(L4::Cap<L4virtio::Device> srvcap, bool manage_notify = true)
  {
    _device = srvcap;
 
    _next_devaddr = L4_SUPERPAGESIZE;
 
    auto *e = L4Re::Env::env();
 
    // Set up the virtio configuration page.
 
    _config_cap = L4Re::chkcap(L4Re::Util::make_unique_cap<L4Re::Dataspace>(),
                               "Allocate config dataspace capability");
 
    l4_addr_t ds_offset;
    L4Re::chksys(_device->device_config(_config_cap.get(), &ds_offset),
                 "Request virtio config page");
 
    if (ds_offset & ~L4_PAGEMASK)
      L4Re::chksys(-L4_EINVAL, "Virtio config page is page aligned.");
 
    L4Re::chksys(e->rm()->attach(&_config, L4_PAGESIZE,
                                 L4Re::Rm::F::Search_addr | L4Re::Rm::F::RW,
                                 L4::Ipc::make_cap_rw(_config_cap.get()), ds_offset,
                                 L4_PAGESHIFT),
                 "Attach config dataspace");
 
    if (memcmp(&_config->magic, "virt", 4) != 0)
      L4Re::chksys(-L4_ENODEV, "Device config has wrong magic value");
 
    if (_config->version != 2)
      L4Re::chksys(-L4_ENODEV, "Invalid virtio version, must be 2");
 
    _device->set_status(0); // reset
    int status = L4VIRTIO_STATUS_ACKNOWLEDGE;
    _device->set_status(status);
 
    status |= L4VIRTIO_STATUS_DRIVER;
    _device->set_status(status);
 
    if (_config->fail_state())
      L4Re::chksys(-L4_EIO, "Device failure during initialisation.");
 
    // Set up the interrupt used to notify the device about events.
    // (only supporting one interrupt with index 0 at the moment)
 
    _host_irq = L4Re::chkcap(L4Re::Util::make_unique_cap<L4::Irq>(),
                             "Allocate host IRQ capability");
 
    L4Re::chksys(_device->device_notification_irq(0, _host_irq.get()),
                 "Request device notification interrupt.");
 
    // Set up the interrupt to get notifications from the device.
    // (only supporting one interrupt with index 0 at the moment)
    if (manage_notify)
      {
        _driver_notification =
          L4Re::chkcap(L4Re::Util::make_unique_cap<L4::Semaphore>(),
                       "Allocate notification capability");
 
        L4Re::chksys(l4_error(e->factory()->create(_driver_notification.get())),
                     "Create semaphore for notifications from device");
 
        L4Re::chksys(_device->bind(0, _driver_notification.get()),
                     "Bind driver notification interrupt");
      }
  }
 
  int bind_notification_irq(unsigned index, L4::Cap<L4::Triggerable> irq) const
  { return l4_error(_device->bind(index, irq)); }
 
  bool fail_state() const { return _config->fail_state(); }
 
  bool feature_negotiated(unsigned int feat) const
  { return l4virtio_get_feature(_config->driver_features_map, feat); }
 
  int driver_acknowledge()
  {
    if (!l4virtio_get_feature(_config->dev_features_map,
                              L4VIRTIO_FEATURE_VERSION_1))
      L4Re::chksys(-L4_ENODEV,
                   "Require Virtio 1.0 device; Legacy device not supported.");
 
    _config->driver_features_map[0] &= _config->dev_features_map[0];
    _config->driver_features_map[1] &= _config->dev_features_map[1];
 
    _device->set_status(_config->status | L4VIRTIO_STATUS_FEATURES_OK);
 
    if (!(_config->status & L4VIRTIO_STATUS_FEATURES_OK))
      L4Re::chksys(-L4_EINVAL, "Negotiation of device features.");
 
    _device->set_status(_config->status | L4VIRTIO_STATUS_DRIVER_OK);
 
    if (_config->fail_state())
      return -L4_EIO;
 
    return L4_EOK;
  }
 
  int register_ds(L4::Cap<L4Re::Dataspace> ds, l4_umword_t offset,
                  l4_umword_t size, l4_uint64_t *devaddr)
  {
    *devaddr = next_device_address(size);
    return _device->register_ds(L4::Ipc::make_cap_rw(ds), *devaddr, offset, size);
  }
 
  int config_queue(int num, unsigned size, l4_uint64_t desc_addr,
                   l4_uint64_t avail_addr, l4_uint64_t used_addr)
  {
    auto *queueconf = &_config->queues()[num];
    queueconf->num = size;
    queueconf->desc_addr = desc_addr;
    queueconf->avail_addr = avail_addr;
    queueconf->used_addr = used_addr;
    queueconf->ready = 1;
 
    return _device->config_queue(num);
  }
 
  int max_queue_size(int num) const
  {
    return _config->queues()[num].num_max;
  }
 
  int send_and_wait(Virtqueue &queue, l4_uint16_t descno)
  {
    send(queue, descno);
 
    // wait for a reply, we assume that no other
    // request will get in the way.
    auto head = wait_for_next_used(queue);
 
    if (head < 0)
      return head;
 
    return (head == descno) ? L4_EOK : -L4_EINVAL;
  }
 
  int wait(int index) const
  {
    if (index != 0)
      return -L4_EEXIST;
 
    return l4_ipc_error(_driver_notification->down(), l4_utcb());
  }
 
  int wait_for_next_used(Virtqueue &queue, l4_uint32_t *len = nullptr) const
  {
    while (true)
      {
        int err = wait(0);
 
        if (err < 0)
          return err;
 
        auto head = queue.find_next_used(len);
        if (head != Virtqueue::Eoq) // spurious interrupt?
          return head;
      }
  }
 
  void send(Virtqueue &queue, l4_uint16_t descno)
  {
    queue.enqueue_descriptor(descno);
    notify(queue);
  }
 
  void notify(Virtqueue &queue)
  {
    if (!queue.no_notify_host())
      _host_irq->trigger();
  }
 
private:
  l4_uint64_t next_device_address(l4_umword_t size)
  {
    l4_umword_t ret;
    size = l4_round_page(size);
    do
      {
        ret = _next_devaddr;
        if (l4_umword_t(~0) - ret < size)
          L4Re::chksys(-L4_ENOMEM, "Out of device address space.");
      }
    while (!l4util_cmpxchg(&_next_devaddr, ret, ret + size));
 
    return ret;
  }
 
protected:
  L4::Cap<L4virtio::Device> _device;
  L4Re::Rm::Unique_region<L4virtio::Device::Config_hdr *> _config;
  l4_umword_t _next_devaddr;
  L4Re::Util::Unique_cap<L4::Semaphore> _driver_notification;
 
private:
  L4Re::Util::Unique_cap<L4::Irq> _host_irq;
  L4Re::Util::Unique_cap<L4Re::Dataspace> _config_cap;
};
 
} }