virtio.h

/* 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 <l4/sys/utcb.h>
#include <l4/sys/ipc.h>
#include <l4/sys/types.h>
 
enum L4_virtio_protocol
{
  L4VIRTIO_PROTOCOL = 0,
};
 
enum L4virtio_magic
{
  L4VIRTIO_MAGIC = 0x74726976
};
 
enum L4virtio_vendor
{
  L4VIRTIO_VENDOR_KK = 0x44
};
 
enum L4_virtio_opcodes
{
  L4VIRTIO_OP_SET_STATUS     = 0, 
  L4VIRTIO_OP_CONFIG_QUEUE   = 1, 
  L4VIRTIO_OP_REGISTER_DS    = 3, 
  L4VIRTIO_OP_DEVICE_CONFIG  = 4, 
  L4VIRTIO_OP_GET_DEVICE_IRQ = 5, 
};
 
enum L4virtio_device_ids
{
  L4VIRTIO_ID_NET           = 1,      
  L4VIRTIO_ID_BLOCK         = 2,      
  L4VIRTIO_ID_CONSOLE       = 3,      
  L4VIRTIO_ID_RNG           = 4,      
  L4VIRTIO_ID_BALLOON       = 5,      
  L4VIRTIO_ID_RPMSG         = 7,      
  L4VIRTIO_ID_SCSI          = 8,      
  L4VIRTIO_ID_9P            = 9,      
  L4VIRTIO_ID_RPROC_SERIAL  = 11,     
  L4VIRTIO_ID_CAIF          = 12,     
  L4VIRTIO_ID_GPU           = 16,     
  L4VIRTIO_ID_INPUT         = 18,     
  L4VIRTIO_ID_VSOCK         = 19,     
  L4VIRTIO_ID_CRYPTO        = 20,     
  L4VIRTIO_ID_FS            = 26,     
  L4VIRTIO_ID_SCMI          = 32,     
  L4VIRTIO_ID_SOCK          = 0x9999, 
};
 
enum L4virtio_device_status
{
  L4VIRTIO_STATUS_ACKNOWLEDGE = 1,   
  L4VIRTIO_STATUS_DRIVER      = 2,   
  L4VIRTIO_STATUS_DRIVER_OK   = 4,   
  L4VIRTIO_STATUS_FEATURES_OK = 8,   
  L4VIRTIO_STATUS_DEVICE_NEEDS_RESET = 0x40, 
  L4VIRTIO_STATUS_FAILED      = 0x80 
};
 
enum L4virtio_feature_bits
{
  L4VIRTIO_FEATURE_VERSION_1  = 32,
  L4VIRTIO_FEATURE_CMD_CONFIG = 160
};
 
enum L4_virtio_irq_status
{
  L4VIRTIO_IRQ_STATUS_VRING  = 1, 
  L4VIRTIO_IRQ_STATUS_CONFIG = 2, 
};
 
enum L4_virtio_cmd
{
  L4VIRTIO_CMD_NONE         = 0x00000000, 
  L4VIRTIO_CMD_SET_STATUS   = 0x01000000, 
  L4VIRTIO_CMD_CFG_QUEUE    = 0x02000000, 
  L4VIRTIO_CMD_CFG_CHANGED  = 0x04000000, 
  L4VIRTIO_CMD_NOTIFY_QUEUE = 0x08000000, 
  L4VIRTIO_CMD_MASK         = 0xff000000, 
};
 
typedef struct l4virtio_config_hdr_t
{
  /* Virtio(0x00): device config */
  l4_uint32_t magic;          
  l4_uint32_t version;        
  l4_uint32_t device;         
  l4_uint32_t vendor;         
  /* Virtio(0x10): device features */
  l4_uint32_t dev_features;   
  l4_uint32_t dev_features_sel;
  l4_uint32_t _res1[2];
 
  /* Virtio(0x20): driver features */
  l4_uint32_t driver_features;
  l4_uint32_t driver_features_sel;
 
  /* L4Virtio(0x28): L4 queue */
  l4_uint32_t num_queues;     
  l4_uint32_t queues_offset;  
  /* Virtio(0x30): queue status */
  l4_uint32_t queue_sel;
  l4_uint32_t queue_num_max;
  l4_uint32_t queue_num;
  l4_uint32_t _res3[2];
  l4_uint32_t queue_ready;
  l4_uint32_t _res4[2];
 
  /* Virtio(0x50): queue notify */
  l4_uint32_t queue_notify;
  l4_uint32_t _res5[3];
 
  /* Virtio(0x60): interrupt handling */
  l4_uint32_t irq_status;
  l4_uint32_t irq_ack;
  l4_uint32_t _res6[2];
 
  /* Virtio(0x70): Device status register (read-only). The register must be
   * written using l4virtio_set_status(). */
  l4_uint32_t status;
 
  /* L4Virtio(0x74): W: Event index to be used for config notifications (device to driver) */
  l4_uint32_t cfg_driver_notify_index;
  /* L4Virtio(0x78): R: Event index to be used for config notifications (driver to device) */
  l4_uint32_t cfg_device_notify_index;
 
  /* L4Virtio(0x7c) L4 specific command register polled by the driver iff supported */
  l4_uint32_t cmd;
 
  /* Virtio(0x80): queue descriptors */
  l4_uint64_t queue_desc;
  l4_uint32_t _res8[2];
  l4_uint64_t queue_avail;
  l4_uint32_t _res9[2];
  l4_uint64_t queue_used;
 
  l4_uint32_t _res10[1];
 
  /* Virtio(0xac): shared memory region */
  l4_uint32_t shm_sel;
  l4_uint64_t shm_len;
  l4_uint64_t shm_base;
 
  /* L4Virtio(0xc0): use the unused space here for device and driver feature bitmaps */
  l4_uint32_t dev_features_map[6];
  l4_uint32_t _res11[2];
  l4_uint32_t driver_features_map[6];
  l4_uint32_t _res12[1];
 
  /* Virtio(0xfc): config generation */
  l4_uint32_t generation;
} l4virtio_config_hdr_t;
 
typedef struct l4virtio_config_queue_t
{
  l4_uint16_t num_max;
  l4_uint16_t num;
 
  l4_uint16_t ready;
 
  l4_uint16_t driver_notify_index;
 
  l4_uint64_t desc_addr;  
  l4_uint64_t avail_addr; 
  l4_uint64_t used_addr;  
  l4_uint16_t device_notify_index;
} l4virtio_config_queue_t;
 
EXTERN_C_BEGIN
 
L4_INLINE l4virtio_config_queue_t *
l4virtio_config_queues(l4virtio_config_hdr_t const *cfg)
{
  return (l4virtio_config_queue_t *)(((l4_addr_t)cfg) + cfg->queues_offset);
}
 
L4_INLINE void *
l4virtio_device_config(l4virtio_config_hdr_t const *cfg)
{
  return (void *)(((l4_addr_t)cfg) + 0x100);
}
 
L4_INLINE void
l4virtio_set_feature(l4_uint32_t *feature_map, unsigned feat)
{
  unsigned idx = feat / 32;
 
  if (idx < 8)
    feature_map[idx] |= 1UL << (feat % 32);
}
 
L4_INLINE void
l4virtio_clear_feature(l4_uint32_t *feature_map, unsigned feat)
{
  unsigned idx = feat / 32;
 
  if (idx < 8)
    feature_map[idx] &= ~(1UL << (feat % 32));
}
 
L4_INLINE unsigned
l4virtio_get_feature(l4_uint32_t *feature_map, unsigned feat)
{
  unsigned idx = feat / 32;
 
  if (idx >= 8)
    return 0;
 
  return feature_map[idx] & (1UL << (feat % 32));
}
 
L4_CV int
l4virtio_set_status(l4_cap_idx_t cap, unsigned status) L4_NOTHROW;
 
L4_CV int
l4virtio_config_queue(l4_cap_idx_t cap, unsigned queue) L4_NOTHROW;
 
L4_CV int
l4virtio_register_ds(l4_cap_idx_t cap, l4_cap_idx_t ds_cap,
                     l4_uint64_t base, l4_umword_t offset,
                     l4_umword_t size) L4_NOTHROW;
 
L4_CV int
l4virtio_device_config_ds(l4_cap_idx_t cap, l4_cap_idx_t config_ds,
                          l4_addr_t *ds_offset) L4_NOTHROW;
 
L4_CV int
l4virtio_device_notification_irq(l4_cap_idx_t cap, unsigned index,
                                 l4_cap_idx_t irq) L4_NOTHROW;
 
EXTERN_C_END