XHCI works on real hardware!

kernel/mm/pmm.c

@@ -5,7 +5,6 @@
 #include <limine/limine.h>
 #include <limine/requests.h>
 #include <mm/pmm.h>
-#include <mm/types.h>
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 #include <sys/mm.h>
@@ -43,15 +42,15 @@ void pmm_init (void) {
        * */
 
       size_t size = align_down (entry->length, PAGE_SIZE);
-      physaddr_t start = align_up (entry->base, PAGE_SIZE);
+      uintptr_t start = align_up (entry->base, PAGE_SIZE);
 
       size_t max_pages = (size * 8) / (PAGE_SIZE * 8 + 1);
 
       size_t bm_nbits = max_pages;
       size_t bm_size = align_up (bm_nbits, 8) / 8;
 
-      physaddr_t bm_base = start;
-      physaddr_t data_base = align_up (bm_base + bm_size, PAGE_SIZE);
+      uintptr_t bm_base = start;
+      uintptr_t data_base = align_up (bm_base + bm_size, PAGE_SIZE);
 
       if (bm_base + bm_size >= start + size)
         continue;
@@ -99,7 +98,23 @@ static size_t pmm_find_free_space (struct pmm_region* pmm_region, size_t nblks)
   return (size_t)-1;
 }
 
-physaddr_t pmm_alloc (size_t nblks) {
+static size_t pmm_find_free_space_aligned (struct pmm_region* pmm_region, size_t nblks,
+                                           size_t align_pages) {
+  if (align_pages == 0)
+    align_pages = 1;
+
+  for (size_t bit = 0; bit < pmm_region->bm.nbits; bit += align_pages) {
+    if (bm_test_region (&pmm_region->bm, bit, nblks)) {
+      continue;
+    }
+
+    return bit;
+  }
+
+  return (size_t)-1;
+}
+
+uintptr_t pmm_alloc (size_t nblks) {
   uint64_t fpr;
 
   for (size_t region = 0; region < PMM_REGIONS_MAX; region++) {
@@ -129,11 +144,41 @@ physaddr_t pmm_alloc (size_t nblks) {
   return PMM_ALLOC_ERR;
 }
 
-void pmm_free (physaddr_t p_addr, size_t nblks) {
+uintptr_t pmm_alloc_aligned (size_t nblks, size_t align_pages) {
+  uint64_t fpr;
+
+  for (size_t region = 0; region < PMM_REGIONS_MAX; region++) {
+    struct pmm_region* pmm_region = &pmm.regions[region];
+
+    /* Inactive region, so don't bother with it. */
+    if (!(pmm_region->flags & PMM_REGION_ACTIVE))
+      continue;
+
+    spin_lock (&pmm_region->lock, &fpr);
+
+    /* Find starting bit of the free bit range */
+    size_t bit = pmm_find_free_space_aligned (pmm_region, nblks, align_pages);
+
+    /* Found a free range? */
+    if (bit != (size_t)-1) {
+      /* Mark it */
+      bm_set_region (&pmm_region->bm, bit, nblks);
+      spin_unlock (&pmm_region->lock, fpr);
+
+      return pmm_region->membase + bit * PAGE_SIZE;
+    }
+
+    spin_unlock (&pmm_region->lock, fpr);
+  }
+
+  return PMM_ALLOC_ERR;
+}
+
+void pmm_free (uintptr_t p_addr, size_t nblks) {
   uint64_t fpr;
 
   /* Round down to nearest page boundary */
-  physaddr_t aligned_p_addr = align_down (p_addr, PAGE_SIZE);
+  uintptr_t aligned_p_addr = align_down (p_addr, PAGE_SIZE);
 
   for (size_t region = 0; region < PMM_REGIONS_MAX; region++) {
     struct pmm_region* pmm_region = &pmm.regions[region];
@@ -145,7 +190,7 @@ void pmm_free (physaddr_t p_addr, size_t nblks) {
     /* If aligned_p_addr is within the range if this region, it belongs to it. */
     if (aligned_p_addr >= pmm_region->membase &&
         aligned_p_addr < pmm_region->membase + pmm_region->size) {
-      physaddr_t addr = aligned_p_addr - pmm_region->membase;
+      uintptr_t addr = aligned_p_addr - pmm_region->membase;
 
       size_t bit = div_align_up (addr, PAGE_SIZE);