WIP [dev][virtio][pci] PCI based virtio

Mostly wired up at this point for virtio-block.
Interrupts are wired up (non MSI-X) but not seeing any results after
submitting a block transfer. Unclear if kick is not working.

arch/x86/include/arch/arch_ops.h

@@ -91,5 +91,4 @@ static inline uint arch_curr_cpu_num(void) {
 #define smp_rmb()   CF
 #endif
 
-
 #endif // !ASSEMBLY

dev/bus/pci/bus_mgr/bus_mgr.cpp

@@ -323,6 +323,18 @@ status_t pci_bus_mgr_allocate_irq(const pci_location_t loc, uint *irqbase) {
     return d->allocate_irq(irqbase);
 }
 
+ssize_t pci_read_vendor_capability(const pci_location_t loc, size_t index, void *buf, size_t buflen) {
+    char str[14];
+    LTRACEF("%s\n", pci_loc_string(loc, str));
+
+    device *d = lookup_device_by_loc(loc);
+    if (!d) {
+        return ERR_NOT_FOUND;
+    }
+
+    return d->read_vendor_capability(index, buf, buflen);
+}
+
 void pci_dump_bar(const pci_bar_t *bar, int index) {
     if (bar->addr >= UINT32_MAX || bar->size >= UINT32_MAX) {
         printf("BAR %d: addr %-#16llx size %-#16zx io %d 64b %d pref %d\n",

dev/bus/pci/bus_mgr/device.cpp

@@ -133,6 +133,14 @@ void device::dump(size_t indent) {
             pci_dump_bar(bars_ + b, b);
         }
     }
+
+    capability *cap;
+    list_for_every_entry(&capability_list_, cap, capability, node) {
+        for (size_t i = 0; i < indent + 2; i++) {
+            printf(" ");
+        }
+        printf("capability: offset %#x id %#x\n", cap->config_offset, cap->id);
+    }
 }
 
 status_t device::enable() {
@@ -220,6 +228,27 @@ status_t device::probe_capabilities() {
     return NO_ERROR;
 }
 
+ssize_t device::read_vendor_capability(size_t index, void *buf, size_t buflen) {
+    const capability *cap;
+    list_for_every_entry(&capability_list_, cap, capability, node) {
+        if (cap->id == 0x9) { // vendor specific
+            if (index == 0) {
+                uint8_t len;
+                pci_read_config_byte(loc(), cap->config_offset + 2, &len);
+
+                const size_t readlen = MIN(len, buflen);
+                for (size_t i = 0; i < readlen; i++) {
+                    pci_read_config_byte(loc(), cap->config_offset + i, static_cast<uint8_t *>(buf) + i);
+                }
+                return len;
+            }
+            index--;
+        }
+     }
+
+    return ERR_NOT_FOUND;
+}
+
 status_t device::init_msi_capability(capability *cap) {
     LTRACE_ENTRY;
 
@@ -256,16 +285,21 @@ status_t device::init_msix_capability(capability *cap) {
 status_t device::allocate_irq(uint *irq) {
     LTRACE_ENTRY;
 
-    uint8_t interrupt_line;
-    status_t err = pci_read_config_byte(loc(), PCI_CONFIG_INTERRUPT_LINE, &interrupt_line);
+    uint8_t interrupt_pin;
+    status_t err = pci_read_config_byte(loc(), PCI_CONFIG_INTERRUPT_PIN, &interrupt_pin);
     if (err != NO_ERROR) return err;
 
-    if (interrupt_line == 0) {
+    if (interrupt_pin == 0) {
         return ERR_NO_RESOURCES;
     }
 
     // map the irq number in config space to platform vector space
-    err = platform_pci_int_to_vector(interrupt_line, irq);
+    err = platform_pci_int_to_vector(interrupt_pin, irq);
+    if (err != NO_ERROR) return err;
+
+    // write it back to the pci config in the interrupt line offset
+    pci_write_config_byte(loc(), PCI_CONFIG_INTERRUPT_LINE, *irq);
+
     return err;
 }
 

dev/bus/pci/bus_mgr/device.h

@@ -90,6 +90,7 @@ class device {
     uint8_t header_type() const { return config_.header_type & PCI_HEADER_TYPE_MASK; }
 
     status_t read_bars(pci_bar_t bar[6]);
+    ssize_t read_vendor_capability(size_t index, void *buf, size_t buflen);
 
     bool has_msi() const { return msi_cap_; }
     bool has_msix() const { return msix_cap_; }

dev/bus/pci/debug.cpp

@@ -54,10 +54,11 @@ static void pci_list(void) {
 
                     if (config.vendor_id != 0xffff) {
                         printf("%04x:%02x:%02x.%0x vendor_id=%04x device_id=%04x, header_type=%02x "
-                                "base_class=%02x, sub_class=%02x, interface=%02x, irq=%u\n",
+                                "base_class=%02x, sub_class=%02x, interface=%02x, irq_line=%u, irq_pin=%u\n",
                                state.segment, state.bus, state.dev, state.fn,
                                config.vendor_id, config.device_id, config.header_type, config.base_class,
-                               config.sub_class, config.program_interface, config.type0.interrupt_line);
+                               config.sub_class, config.program_interface, config.type0.interrupt_line,
+                               config.type0.interrupt_pin);
                         devices++;
                         lines++;
                     }

dev/bus/pci/drivers/rules.mk

@@ -1,5 +1,7 @@
 # Fake module that just declares deps on all the PCI drivers in the system.
 #
 MODULES += dev/bus/pci
-
 MODULES += dev/net/e1000
+MODULES += dev/virtio/block
+MODULES += dev/virtio/net
+MODULES += dev/virtio/gpu

dev/bus/pci/include/dev/bus/pci.h

@@ -98,6 +98,9 @@ status_t pci_bus_mgr_allocate_msi(const pci_location_t loc, size_t num_requested
 // allocate a regular irq for this device and return it in irqbase
 status_t pci_bus_mgr_allocate_irq(const pci_location_t loc, uint *irqbase);
 
+// XXX sort this nicely
+ssize_t pci_read_vendor_capability(const pci_location_t loc, size_t index, void *buf, size_t buflen);
+
 // return a pointer to a formatted string
 const char *pci_loc_string(pci_location_t loc, char out_str[14]);
 

dev/virtio/include/dev/virtio/virtio-bus.h

@@ -21,4 +21,8 @@ class virtio_bus {
     virtual void virtio_status_driver_ok() = 0;
     virtual void virtio_kick(uint16_t ring_index) = 0;
     virtual void register_ring(uint32_t page_size, uint32_t queue_sel, uint32_t queue_num, uint32_t queue_align, uint32_t queue_pfn) = 0;
+
+    uint64_t virtio_read_host_feature_word_64(uint32_t word) {
+        return virtio_read_host_feature_word(word) | static_cast<uint64_t>(virtio_read_host_feature_word(word + 1)) << 32;
+    }
 };

dev/virtio/include/dev/virtio/virtio-device.h

@@ -13,6 +13,7 @@
 #include <dev/virtio.h>
 #include <dev/virtio/virtio_ring.h>
 #include <dev/virtio/virtio-bus.h>
+#include <platform/interrupts.h>
 
 class virtio_device {
 public:
@@ -52,6 +53,7 @@ class virtio_device {
 
     void *get_config_ptr() { return config_ptr_; }
     const void *get_config_ptr() const { return config_ptr_; }
+    void set_config_ptr(void *ptr) { config_ptr_ = ptr; }
 
     using irq_driver_callback = enum handler_return (*)(virtio_device *dev, uint ring, const vring_used_elem *e);
     using config_change_callback = enum handler_return (*)(virtio_device *dev);
@@ -61,6 +63,17 @@ class virtio_device {
         config_change_callback_ = config;
     }
 
+    // TODO: move this into the bus layer
+    void set_irq(uint irq) { irq_ = irq; }
+
+    void mask_interrupt() {
+        ::mask_interrupt(irq_);
+    }
+
+    void unmask_interrupt() {
+        ::unmask_interrupt(irq_);
+    }
+
     // From low level bus layer
     handler_return handle_queue_interrupt();
     handler_return handle_config_interrupt();

dev/virtio/include/dev/virtio/virtio-pci-bus.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2024 Travis Geiselbrecht
+ *
+ * Use of this source code is governed by a MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT
+ */
+#pragma once
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <dev/virtio/virtio-bus.h>
+
+#include <dev/bus/pci.h>
+
+struct virtio_pci_common_cfg;
+
+class virtio_pci_bus final : public virtio_bus {
+public:
+    virtio_pci_bus() = default;
+    ~virtio_pci_bus() override = default;
+
+    void virtio_reset_device() override;
+    void virtio_status_acknowledge_driver() override;
+    uint32_t virtio_read_host_feature_word(uint32_t word) override;
+    void virtio_set_guest_features(uint32_t word, uint32_t features) override;
+    void virtio_status_driver_ok() override;
+    void virtio_kick(uint16_t ring_index) override;
+
+    void register_ring(uint32_t page_size, uint32_t queue_sel, uint32_t queue_num, uint32_t queue_align, uint32_t queue_pfn) override;
+
+    status_t init(pci_location_t loc, size_t index);
+
+    static handler_return virtio_pci_irq(void *arg);
+
+    volatile virtio_pci_common_cfg *common_config() {
+        return  reinterpret_cast<volatile virtio_pci_common_cfg *>(config_ptr(common_cfg_));
+    }
+
+    void *device_config() {
+        return  reinterpret_cast<void *>(config_ptr(device_cfg_));
+    }
+
+//private:
+    struct config_pointer {
+        bool valid;
+        int bar;
+        size_t offset;
+        size_t length;
+    };
+
+    struct mapped_bars {
+        bool mapped;
+        void *vaddr;
+    };
+
+    pci_location_t loc_ = {};
+
+    mapped_bars bar_map_[6] = {};
+
+    config_pointer common_cfg_ = {};
+    config_pointer notify_cfg_ = {};
+    config_pointer isr_cfg_ = {};
+    config_pointer device_cfg_ = {};
+    config_pointer pci_cfg_ = {};
+
+    uint32_t notify_offset_multiplier_ = {};
+
+    // TODO: handle MSI-X
+    uint32_t irq_ = {};
+
+    void *config_ptr(const config_pointer &cfg) {
+        if (!cfg.valid) {
+            return nullptr;
+        }
+
+        auto &bar = bar_map_[cfg.bar];
+        return (void *)((uintptr_t)bar.vaddr + cfg.offset);
+    }
+
+};

dev/virtio/net/virtio-net.cpp

@@ -195,7 +195,7 @@ status_t virtio_net_init(virtio_device *dev) {
     dev->bus()->virtio_status_acknowledge_driver();
 
     // XXX check features bits and ack/nak them
-    uint64_t host_features = dev->bus()->virtio_read_host_feature_word(0) | (uint64_t)dev->bus()->virtio_read_host_feature_word(1) << 32;
+    uint64_t host_features = dev->bus()->virtio_read_host_feature_word_64(0);
     dump_feature_bits(host_features);
 
     /* set our irq handler */

dev/virtio/rules.mk

@@ -2,9 +2,10 @@ LOCAL_DIR := $(GET_LOCAL_DIR)
 
 MODULE := $(LOCAL_DIR)
 
-MODULE_SRCS += $(LOCAL_DIR)/virtio.cpp
 MODULE_SRCS += $(LOCAL_DIR)/virtio-bus.cpp
 MODULE_SRCS += $(LOCAL_DIR)/virtio-device.cpp
 MODULE_SRCS += $(LOCAL_DIR)/virtio-mmio-bus.cpp
+MODULE_SRCS += $(LOCAL_DIR)/virtio-pci-bus.cpp
+MODULE_SRCS += $(LOCAL_DIR)/virtio.cpp
 
 include make/module.mk

dev/virtio/virtio-mmio-bus.cpp

@@ -79,13 +79,6 @@ STATIC_ASSERT(sizeof(struct virtio_mmio_config) == 0x100);
 
 #define VIRTIO_MMIO_MAGIC 0x74726976 // 'virt'
 
-#define VIRTIO_STATUS_ACKNOWLEDGE (1<<0)
-#define VIRTIO_STATUS_DRIVER      (1<<1)
-#define VIRTIO_STATUS_DRIVER_OK   (1<<2)
-#define VIRTIO_STATUS_FEATURES_OK (1<<3)
-#define VIRTIO_STATUS_DEVICE_NEEDS_RESET (1<<6)
-#define VIRTIO_STATUS_FAILED      (1<<7)
-
 // TODO: switch to using reg.h mmio_ accessors
 void virtio_mmio_bus::virtio_reset_device() {
     mmio_config_->status = 0;
@@ -199,7 +192,7 @@ int virtio_mmio_detect(void *ptr, uint count, const uint irqs[], size_t stride)
 
         dev->index_ = i;
         dev->irq_ = irqs[i];
-        dev->config_ptr_ = (void *)mmio->config;
+        dev->set_config_ptr((void *)mmio->config);
 
         mask_interrupt(irqs[i]);
         register_int_handler(irqs[i], &virtio_mmio_bus::virtio_mmio_irq, static_cast<void *>(dev));