Implement virtio-gpu device

Author: shengwen-tw

Makefile

@@ -3,6 +3,7 @@ include mk/common.mk
 CC ?= gcc
 CFLAGS := -O2 -g -Wall -Wextra
 CFLAGS += -include common.h
+LDFLAGS :=
 
 # clock frequency
 CLOCK_FREQ ?= 65000000
@@ -13,6 +14,8 @@ OBJS_EXTRA :=
 # command line option
 OPTS :=
 
+LDFLAGS += -lpthread
+
 # virtio-blk
 ENABLE_VIRTIOBLK ?= 1
 $(call set-feature, VIRTIOBLK)
@@ -43,6 +46,33 @@ ifeq ($(call has, VIRTIONET), 1)
     OBJS_EXTRA += netdev.o
 endif
 
+# virtio-gpu
+ENABLE_VIRTIOGPU ?= 1
+ifneq ($(UNAME_S),Linux)
+    ENABLE_VIRTIOGPU := 0
+endif
+
+# SDL2
+ENABLE_SDL ?= 1
+ifeq (, $(shell which sdl2-config))
+    $(warning No sdl2-config in $$PATH. Check SDL2 installation in advance)
+    override ENABLE_SDL := 0
+endif
+
+ifeq ($(ENABLE_SDL),1)
+    CFLAGS += $(shell sdl2-config --cflags)
+    LDFLAGS += $(shell sdl2-config --libs)
+else
+    override ENABLE_VIRTIOGPU := 0
+endif
+
+ifeq ($(ENABLE_VIRTIOGPU),1)
+    OBJS_EXTRA += window.o
+    OBJS_EXTRA += virtio-gpu.o
+endif
+
+$(call set-feature, VIRTIOGPU)
+
 BIN = semu
 all: $(BIN) minimal.dtb
 

device.h

@@ -8,7 +8,7 @@
 
 #define RAM_SIZE (512 * 1024 * 1024)
 #define DTB_SIZE (1 * 1024 * 1024)
-#define INITRD_SIZE (8 * 1024 * 1024)
+#define INITRD_SIZE (65 * 1024 * 1024)
 
 void ram_read(hart_t *core,
               uint32_t *mem,
@@ -172,6 +172,57 @@ void virtio_blk_write(hart_t *vm,
 uint32_t *virtio_blk_init(virtio_blk_state_t *vblk, char *disk_file);
 #endif /* SEMU_HAS(VIRTIOBLK) */
 
+/* VirtIO-GPU */
+
+#if SEMU_HAS(VIRTIOGPU)
+
+#define IRQ_VGPU 4
+#define IRQ_VGPU_BIT (1 << IRQ_VGPU)
+
+typedef struct {
+    uint32_t QueueNum;
+    uint32_t QueueDesc;
+    uint32_t QueueAvail;
+    uint32_t QueueUsed;
+    uint16_t last_avail;
+    bool ready;
+} virtio_gpu_queue_t;
+
+typedef struct {
+    /* feature negotiation */
+    uint32_t DeviceFeaturesSel;
+    uint32_t DriverFeatures;
+    uint32_t DriverFeaturesSel;
+    /* queue config */
+    uint32_t QueueSel;
+    virtio_gpu_queue_t queues[2];
+    /* status */
+    uint32_t Status;
+    uint32_t InterruptStatus;
+    /* supplied by environment */
+    uint32_t *ram;
+    /* implementation-specific */
+    void *priv;
+} virtio_gpu_state_t;
+
+void virtio_gpu_read(hart_t *vm,
+                     virtio_gpu_state_t *vgpu,
+                     uint32_t addr,
+                     uint8_t width,
+                     uint32_t *value);
+
+void virtio_gpu_write(hart_t *vm,
+                      virtio_gpu_state_t *vgpu,
+                      uint32_t addr,
+                      uint8_t width,
+                      uint32_t value);
+
+void virtio_gpu_init(virtio_gpu_state_t *vgpu);
+void virtio_gpu_add_scanout(virtio_gpu_state_t *vgpu,
+                            uint32_t width,
+                            uint32_t height);
+#endif /* SEMU_HAS(VIRTIOGPU) */
+
 /* ACLINT MTIMER */
 typedef struct {
     /* A MTIMER device has two separate base addresses: one for the MTIME
@@ -272,6 +323,9 @@ typedef struct {
 #endif
 #if SEMU_HAS(VIRTIOBLK)
     virtio_blk_state_t vblk;
+#endif
+#if SEMU_HAS(VIRTIOGPU)
+    virtio_gpu_state_t vgpu;
 #endif
     /* ACLINT */
     mtimer_state_t mtimer;

feature.h

@@ -12,5 +12,10 @@
 #define SEMU_FEATURE_VIRTIONET 1
 #endif
 
+/* virtio-gpu */
+#ifndef SEMU_FEATURE_VIRTIOGPU
+#define SEMU_FEATURE_VIRTIOGPU 1
+#endif
+
 /* Feature test macro */
 #define SEMU_HAS(x) SEMU_FEATURE_##x

list.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <stddef.h>
+
+#define container_of(ptr, type, member) \
+    ((type *) ((void *) ptr - offsetof(type, member)))
+
+#define list_entry(ptr, type, member) container_of(ptr, type, member)
+
+#define list_first_entry(ptr, type, member) \
+    list_entry((ptr)->next, type, member)
+
+#define list_prev_entry(pos, member) \
+    list_entry((pos)->member.prev, typeof(*(pos)), member)
+
+#define list_next_entry(pos, member) \
+    list_entry((pos)->member.next, typeof(*(pos)), member)
+
+#define list_entry_is_head(pos, head, member) (&pos->member == (head))
+
+#define list_for_each(pos, head) \
+    for ((pos) = (head)->next; (pos) != (head); (pos) = (pos)->next)
+
+#define list_for_each_safe(pos, _next, head)                       \
+    for (pos = (head)->next, _next = (pos)->next; (pos) != (head); \
+         (pos) = _next, _next = (pos)->next)
+
+#define list_for_each_entry(pos, head, member)                   \
+    for (pos = list_first_entry(head, __typeof__(*pos), member); \
+         &pos->member != (head); pos = list_next_entry(pos, member))
+
+#define LIST_HEAD_INIT(name)             \
+    {                                    \
+        .prev = (&name), .next = (&name) \
+    }
+
+#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)
+
+struct list_head {
+    struct list_head *next, *prev;
+};
+
+static inline void INIT_LIST_HEAD(struct list_head *list)
+{
+    list->prev = list;
+    list->next = list;
+}
+
+static inline int list_empty(const struct list_head *head)
+{
+    return head->next == head;
+}
+
+static int list_is_last(const struct list_head *list,
+                        const struct list_head *head)
+{
+    return list->next == head;
+}
+
+static inline void list_add(struct list_head *new, struct list_head *list)
+{
+    new->prev = list->prev;
+    new->next = list;
+    list->prev->next = new;
+    list->prev = new;
+}
+
+static inline void list_del(struct list_head *list)
+{
+    list->next->prev = list->prev;
+    list->prev->next = list->next;
+}
+
+static void list_del_init(struct list_head *entry)
+{
+    list_del(entry);
+    INIT_LIST_HEAD(entry);
+}
+
+static inline void list_move(struct list_head *list, struct list_head *new_head)
+{
+    list_del(list);
+    list_add(new_head, list);
+}

main.c

@@ -11,6 +11,7 @@
 #include "device.h"
 #include "riscv.h"
 #include "riscv_private.h"
+#include "window.h"
 
 #define PRIV(x) ((emu_state_t *) x->priv)
 
@@ -72,6 +73,18 @@ static void emu_update_vblk_interrupts(vm_t *vm)
 }
 #endif
 
+#if SEMU_HAS(VIRTIOGPU)
+static void emu_update_vgpu_interrupts(vm_t *vm)
+{
+    emu_state_t *data = PRIV(vm->hart[0]);
+    if (data->vgpu.InterruptStatus)
+        data->plic.active |= IRQ_VGPU_BIT;
+    else
+        data->plic.active &= ~IRQ_VGPU_BIT;
+    plic_update_interrupts(vm, &data->plic);
+}
+#endif
+
 static void emu_update_timer_interrupt(hart_t *hart)
 {
     emu_state_t *data = PRIV(hart);
@@ -137,6 +150,12 @@ static void mem_load(hart_t *hart,
             aclint_sswi_read(hart, &data->sswi, addr & 0xFFFFF, width, value);
             aclint_sswi_update_interrupts(hart, &data->sswi);
             return;
+#if SEMU_HAS(VIRTIOGPU)
+        case 0x46: /* virtio-gpu */
+            virtio_gpu_read(hart, &data->vgpu, addr & 0xFFFFF, width, value);
+            emu_update_vgpu_interrupts(hart->vm);
+            return;
+#endif
         }
     }
     vm_set_exception(hart, RV_EXC_LOAD_FAULT, hart->exc_val);
@@ -191,6 +210,12 @@ static void mem_store(hart_t *hart,
             aclint_sswi_write(hart, &data->sswi, addr & 0xFFFFF, width, value);
             aclint_sswi_update_interrupts(hart, &data->sswi);
             return;
+#if SEMU_HAS(VIRTIOGPU)
+        case 0x46: /* virtio-gpu */
+            virtio_gpu_write(hart, &data->vgpu, addr & 0xFFFFF, width, value);
+            emu_update_vgpu_interrupts(hart->vm);
+            return;
+#endif
         }
     }
     vm_set_exception(hart, RV_EXC_STORE_FAULT, hart->exc_val);
@@ -623,6 +648,12 @@ static int semu_start(int argc, char **argv)
     emu.mtimer.mtimecmp = calloc(vm.n_hart, sizeof(uint64_t));
     emu.mswi.msip = calloc(vm.n_hart, sizeof(uint32_t));
     emu.sswi.ssip = calloc(vm.n_hart, sizeof(uint32_t));
+#if SEMU_HAS(VIRTIOGPU)
+    emu.vgpu.ram = emu.ram;
+    virtio_gpu_init(&(emu.vgpu));
+    virtio_gpu_add_scanout(&(emu.vgpu), 1024, 768);
+    window_init();
+#endif
 
     /* Emulate */
     uint32_t peripheral_update_ctr = 0;
@@ -648,6 +679,11 @@ static int semu_start(int argc, char **argv)
                 if (emu.vblk.InterruptStatus)
                     emu_update_vblk_interrupts(&vm);
 #endif
+
+#if SEMU_HAS(VIRTIOGPU)
+                if (emu.vgpu.InterruptStatus)
+                    emu_update_vgpu_interrupts(&vm);
+#endif
             }
 
             emu_update_timer_interrupt(vm.hart[i]);

minimal.dts

@@ -17,7 +17,8 @@
     chosen {
         bootargs = "earlycon console=ttyS0";
         stdout-path = "serial0";
-        linux,initrd-start = <0x1f700000>; /* @403 MiB (503 * 1024 * 1024)     */
+        /* Reserve 65MiB for initrd image */
+        linux,initrd-start = <0x1be00000>; /* @406 MiB (446 * 1024 * 1024)     */
         linux,initrd-end = <0x1fefffff>;   /* @511 MiB (511 * 1024 * 1024 - 1) */
     };
 
@@ -63,5 +64,13 @@
             interrupts = <3>;
         };
 #endif
+
+#if SEMU_FEATURE_VIRTIOGPU 
+        gpu0: virtio@4600000 {
+            compatible = "virtio,mmio";
+            reg = <0x4600000 0x200>;
+            interrupts = <4>;
+        };       
+#endif
     };
 };