x86/acpimp: rename module to acpi

This module is likely to do more than provide multi-processor information.

4 files changed, 142 insertions, 142 deletions

diff --git a/arch/x86/Makefrag.am b/arch/x86/Makefrag.am
index 0971530..4ec1f7a 100644
--- a/arch/x86/Makefrag.am
+++ b/arch/x86/Makefrag.am
@@ -24,8 +24,8 @@ x15_LDFLAGS += -m64
 endif AMD64
 
 x15_SOURCES +=                          \
-        arch/x86/machine/acpimp.c       \
-        arch/x86/machine/acpimp.h       \
+        arch/x86/machine/acpi.c         \
+        arch/x86/machine/acpi.h         \
         arch/x86/machine/atcons.c       \
         arch/x86/machine/atcons.h       \
         arch/x86/machine/atkbd.c        \
diff --git a/arch/x86/machine/acpimp.c b/arch/x86/machine/acpi.c
index 0af1ae7..5927e95 100644
--- a/arch/x86/machine/acpimp.c
+++ b/arch/x86/machine/acpi.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Richard Braun.
+ * Copyright (c) 2012-2017 Richard Braun.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,7 +25,7 @@
 #include <kern/kmem.h>
 #include <kern/macros.h>
 #include <kern/panic.h>
-#include <machine/acpimp.h>
+#include <machine/acpi.h>
 #include <machine/biosmem.h>
 #include <machine/cpu.h>
 #include <machine/io.h>
@@ -37,14 +37,14 @@
 /*
  * Alignment of the RSDP.
  */
-#define ACPIMP_RSDP_ALIGN 16
+#define ACPI_RSDP_ALIGN 16
 
 /*
  * Signature of the root system description pointer.
  */
-#define ACPIMP_RSDP_SIG "RSD PTR "
+#define ACPI_RSDP_SIG "RSD PTR "
 
-struct acpimp_rsdp {
+struct acpi_rsdp {
     uint8_t signature[8];
     uint8_t checksum;
     uint8_t oem_id[6];
@@ -55,9 +55,9 @@ struct acpimp_rsdp {
 /*
  * Size of a buffer which can store a table signature as a string.
  */
-#define ACPIMP_SIG_SIZE 5
+#define ACPI_SIG_SIZE 5
 
-struct acpimp_sdth {
+struct acpi_sdth {
     uint8_t signature[4];
     uint32_t length;
     uint8_t revision;
@@ -69,90 +69,90 @@ struct acpimp_sdth {
     uint32_t creator_revision;
 } __packed;
 
-struct acpimp_rsdt {
-    struct acpimp_sdth header;
+struct acpi_rsdt {
+    struct acpi_sdth header;
     uint32_t entries[0];
 } __packed;
 
 /*
  * MADT entry type codes.
  */
-#define ACPIMP_MADT_ENTRY_LAPIC     0
-#define ACPIMP_MADT_ENTRY_IOAPIC    1
+#define ACPI_MADT_ENTRY_LAPIC     0
+#define ACPI_MADT_ENTRY_IOAPIC    1
 
-struct acpimp_madt_entry_hdr {
+struct acpi_madt_entry_hdr {
     uint8_t type;
     uint8_t length;
 } __packed;
 
-#define ACPIMP_MADT_LAPIC_ENABLED 0x1
+#define ACPI_MADT_LAPIC_ENABLED 0x1
 
-struct acpimp_madt_entry_lapic {
-    struct acpimp_madt_entry_hdr header;
+struct acpi_madt_entry_lapic {
+    struct acpi_madt_entry_hdr header;
     uint8_t processor_id;
     uint8_t apic_id;
     uint32_t flags;
 } __packed;
 
-struct acpimp_madt_entry_ioapic {
-    struct acpimp_madt_entry_hdr header;
+struct acpi_madt_entry_ioapic {
+    struct acpi_madt_entry_hdr header;
     uint8_t id;
     uint8_t _reserved;
     uint32_t addr;
     uint32_t base;
 } __packed;
 
-union acpimp_madt_entry {
+union acpi_madt_entry {
     uint8_t type;
-    struct acpimp_madt_entry_hdr header;
-    struct acpimp_madt_entry_lapic lapic;
-    struct acpimp_madt_entry_ioapic ioapic;
+    struct acpi_madt_entry_hdr header;
+    struct acpi_madt_entry_lapic lapic;
+    struct acpi_madt_entry_ioapic ioapic;
 } __packed;
 
-struct acpimp_madt {
-    struct acpimp_sdth header;
+struct acpi_madt {
+    struct acpi_sdth header;
     uint32_t lapic_addr;
     uint32_t flags;
-    union acpimp_madt_entry entries[0];
+    union acpi_madt_entry entries[0];
 } __packed;
 
-struct acpimp_madt_iter {
-    const union acpimp_madt_entry *entry;
-    const union acpimp_madt_entry *end;
+struct acpi_madt_iter {
+    const union acpi_madt_entry *entry;
+    const union acpi_madt_entry *end;
 };
 
-#define acpimp_madt_foreach(madt, iter) \
-for (acpimp_madt_iter_init(iter, madt); \
-     acpimp_madt_iter_valid(iter);      \
-     acpimp_madt_iter_next(iter))
+#define acpi_madt_foreach(madt, iter) \
+for (acpi_madt_iter_init(iter, madt); \
+     acpi_madt_iter_valid(iter);      \
+     acpi_madt_iter_next(iter))
 
-struct acpimp_table_addr {
+struct acpi_table_addr {
     const char *sig;
-    struct acpimp_sdth *table;
+    struct acpi_sdth *table;
 };
 
-static struct acpimp_table_addr acpimp_table_addrs[] __initdata = {
+static struct acpi_table_addr acpi_table_addrs[] __initdata = {
     { "RSDT",   NULL },
     { "APIC",   NULL }
 };
 
 static void __init
-acpimp_table_sig(const struct acpimp_sdth *table, char sig[ACPIMP_SIG_SIZE])
+acpi_table_sig(const struct acpi_sdth *table, char sig[ACPI_SIG_SIZE])
 {
     memcpy(sig, table->signature, sizeof(table->signature));
     sig[4] = '\0';
 }
 
 static int __init
-acpimp_table_required(const struct acpimp_sdth *table)
+acpi_table_required(const struct acpi_sdth *table)
 {
-    char sig[ACPIMP_SIG_SIZE];
+    char sig[ACPI_SIG_SIZE];
     size_t i;
 
-    acpimp_table_sig(table, sig);
+    acpi_table_sig(table, sig);
 
-    for (i = 0; i < ARRAY_SIZE(acpimp_table_addrs); i++)
-        if (strcmp(sig, acpimp_table_addrs[i].sig) == 0) {
+    for (i = 0; i < ARRAY_SIZE(acpi_table_addrs); i++)
+        if (strcmp(sig, acpi_table_addrs[i].sig) == 0) {
             return 1;
         }
 
@@ -160,50 +160,50 @@ acpimp_table_required(const struct acpimp_sdth *table)
 }
 
 static void __init
-acpimp_register_table(struct acpimp_sdth *table)
+acpi_register_table(struct acpi_sdth *table)
 {
-    char sig[ACPIMP_SIG_SIZE];
+    char sig[ACPI_SIG_SIZE];
     size_t i;
 
-    acpimp_table_sig(table, sig);
+    acpi_table_sig(table, sig);
 
-    for (i = 0; i < ARRAY_SIZE(acpimp_table_addrs); i++)
-        if (strcmp(sig, acpimp_table_addrs[i].sig) == 0) {
-            if (acpimp_table_addrs[i].table != NULL) {
-                printf("acpimp: warning: table %s ignored:"
+    for (i = 0; i < ARRAY_SIZE(acpi_table_addrs); i++)
+        if (strcmp(sig, acpi_table_addrs[i].sig) == 0) {
+            if (acpi_table_addrs[i].table != NULL) {
+                printf("acpi: warning: table %s ignored:"
                        " already registered\n", sig);
                 return;
             }
 
-            acpimp_table_addrs[i].table = table;
+            acpi_table_addrs[i].table = table;
             return;
         }
 
-    printf("acpimp: warning: table '%s' ignored: unknown table\n", sig);
+    printf("acpi: warning: table '%s' ignored: unknown table\n", sig);
 }
 
-static struct acpimp_sdth * __init
-acpimp_lookup_table(const char *sig)
+static struct acpi_sdth * __init
+acpi_lookup_table(const char *sig)
 {
     size_t i;
 
-    for (i = 0; i < ARRAY_SIZE(acpimp_table_addrs); i++)
-        if (strcmp(sig, acpimp_table_addrs[i].sig) == 0) {
-            return acpimp_table_addrs[i].table;
+    for (i = 0; i < ARRAY_SIZE(acpi_table_addrs); i++)
+        if (strcmp(sig, acpi_table_addrs[i].sig) == 0) {
+            return acpi_table_addrs[i].table;
         }
 
     return NULL;
 }
 
 static int __init
-acpimp_check_tables(void)
+acpi_check_tables(void)
 {
     size_t i;
 
-    for (i = 0; i < ARRAY_SIZE(acpimp_table_addrs); i++)
-        if (acpimp_table_addrs[i].table == NULL) {
-            printf("acpimp: error: table %s missing\n",
-                   acpimp_table_addrs[i].sig);
+    for (i = 0; i < ARRAY_SIZE(acpi_table_addrs); i++)
+        if (acpi_table_addrs[i].table == NULL) {
+            printf("acpi: error: table %s missing\n",
+                   acpi_table_addrs[i].sig);
             return -1;
         }
 
@@ -211,13 +211,13 @@ acpimp_check_tables(void)
 }
 
 static void __init
-acpimp_free_tables(void)
+acpi_free_tables(void)
 {
-    struct acpimp_sdth *table;
+    struct acpi_sdth *table;
     size_t i;
 
-    for (i = 0; i < ARRAY_SIZE(acpimp_table_addrs); i++) {
-        table = acpimp_table_addrs[i].table;
+    for (i = 0; i < ARRAY_SIZE(acpi_table_addrs); i++) {
+        table = acpi_table_addrs[i].table;
 
         if (table != NULL) {
             kmem_free(table, table->length);
@@ -226,7 +226,7 @@ acpimp_free_tables(void)
 }
 
 static unsigned int __init
-acpimp_checksum(const void *ptr, size_t size)
+acpi_checksum(const void *ptr, size_t size)
 {
     const uint8_t *bytes;
     uint8_t checksum;
@@ -243,15 +243,15 @@ acpimp_checksum(const void *ptr, size_t size)
 }
 
 static int __init
-acpimp_check_rsdp(const struct acpimp_rsdp *rsdp)
+acpi_check_rsdp(const struct acpi_rsdp *rsdp)
 {
     unsigned int checksum;
 
-    if (memcmp(rsdp->signature, ACPIMP_RSDP_SIG, sizeof(rsdp->signature)) != 0) {
+    if (memcmp(rsdp->signature, ACPI_RSDP_SIG, sizeof(rsdp->signature)) != 0) {
         return -1;
     }
 
-    checksum = acpimp_checksum(rsdp, sizeof(*rsdp));
+    checksum = acpi_checksum(rsdp, sizeof(*rsdp));
 
     if (checksum != 0) {
         return -1;
@@ -261,29 +261,29 @@ acpimp_check_rsdp(const struct acpimp_rsdp *rsdp)
 }
 
 static int __init
-acpimp_get_rsdp(phys_addr_t start, size_t size, struct acpimp_rsdp *rsdp)
+acpi_get_rsdp(phys_addr_t start, size_t size, struct acpi_rsdp *rsdp)
 {
-    const struct acpimp_rsdp *src;
+    const struct acpi_rsdp *src;
     uintptr_t addr, end, map_addr;
     size_t map_size;
     int error;
 
     assert(size > 0);
-    assert(P2ALIGNED(size, ACPIMP_RSDP_ALIGN));
+    assert(P2ALIGNED(size, ACPI_RSDP_ALIGN));
 
-    if (!P2ALIGNED(start, ACPIMP_RSDP_ALIGN)) {
+    if (!P2ALIGNED(start, ACPI_RSDP_ALIGN)) {
         return -1;
     }
 
     addr = (uintptr_t)vm_kmem_map_pa(start, size, &map_addr, &map_size);
 
     if (addr == 0) {
-        panic("acpimp: unable to map bios memory in kernel map");
+        panic("acpi: unable to map bios memory in kernel map");
     }
 
-    for (end = addr + size; addr < end; addr += ACPIMP_RSDP_ALIGN) {
-        src = (const struct acpimp_rsdp *)addr;
-        error = acpimp_check_rsdp(src);
+    for (end = addr + size; addr < end; addr += ACPI_RSDP_ALIGN) {
+        src = (const struct acpi_rsdp *)addr;
+        error = acpi_check_rsdp(src);
 
         if (!error) {
             break;
@@ -304,7 +304,7 @@ out:
 }
 
 static int __init
-acpimp_find_rsdp(struct acpimp_rsdp *rsdp)
+acpi_find_rsdp(struct acpi_rsdp *rsdp)
 {
     const uint16_t *ptr;
     uintptr_t base, map_addr;
@@ -314,7 +314,7 @@ acpimp_find_rsdp(struct acpimp_rsdp *rsdp)
     ptr = vm_kmem_map_pa(BIOSMEM_EBDA_PTR, sizeof(*ptr), &map_addr, &map_size);
 
     if (ptr == NULL) {
-        panic("acpimp: unable to map ebda pointer in kernel map");
+        panic("acpi: unable to map ebda pointer in kernel map");
     }
 
     base = *((const volatile uint16_t *)ptr);
@@ -322,40 +322,40 @@ acpimp_find_rsdp(struct acpimp_rsdp *rsdp)
 
     if (base != 0) {
         base <<= 4;
-        error = acpimp_get_rsdp(base, 1024, rsdp);
+        error = acpi_get_rsdp(base, 1024, rsdp);
 
         if (!error) {
             return 0;
         }
     }
 
-    error = acpimp_get_rsdp(BIOSMEM_EXT_ROM, BIOSMEM_END - BIOSMEM_EXT_ROM,
+    error = acpi_get_rsdp(BIOSMEM_EXT_ROM, BIOSMEM_END - BIOSMEM_EXT_ROM,
                             rsdp);
 
     if (!error) {
         return 0;
     }
 
-    printf("acpimp: unable to find root system description pointer\n");
+    printf("acpi: unable to find root system description pointer\n");
     return -1;
 }
 
 static void __init
-acpimp_info(void)
+acpi_info(void)
 {
-    const struct acpimp_sdth *rsdt;
+    const struct acpi_sdth *rsdt;
 
-    rsdt = acpimp_lookup_table("RSDT");
+    rsdt = acpi_lookup_table("RSDT");
     assert(rsdt != NULL);
-    printf("acpimp: revision: %u, oem: %.*s\n", rsdt->revision,
+    printf("acpi: revision: %u, oem: %.*s\n", rsdt->revision,
            (int)sizeof(rsdt->oem_id), rsdt->oem_id);
 }
 
-static struct acpimp_sdth * __init
-acpimp_copy_table(uint32_t addr)
+static struct acpi_sdth * __init
+acpi_copy_table(uint32_t addr)
 {
-    const struct acpimp_sdth *table;
-    struct acpimp_sdth *copy;
+    const struct acpi_sdth *table;
+    struct acpi_sdth *copy;
     uintptr_t map_addr;
     size_t size, map_size;
     unsigned int checksum;
@@ -363,30 +363,30 @@ acpimp_copy_table(uint32_t addr)
     table = vm_kmem_map_pa(addr, sizeof(*table), &map_addr, &map_size);
 
     if (table == NULL) {
-        panic("acpimp: unable to map acpi data in kernel map");
+        panic("acpi: unable to map acpi data in kernel map");
     }
 
-    if (!acpimp_table_required(table)) {
+    if (!acpi_table_required(table)) {
         copy = NULL;
         goto out;
     }
 
-    size = ((const volatile struct acpimp_sdth *)table)->length;
+    size = ((const volatile struct acpi_sdth *)table)->length;
     vm_kmem_unmap_pa(map_addr, map_size);
 
     table = vm_kmem_map_pa(addr, size, &map_addr, &map_size);
 
     if (table == NULL) {
-        panic("acpimp: unable to map acpi data in kernel map");
+        panic("acpi: unable to map acpi data in kernel map");
     }
 
-    checksum = acpimp_checksum(table, size);
+    checksum = acpi_checksum(table, size);
 
     if (checksum != 0) {
-        char sig[ACPIMP_SIG_SIZE];
+        char sig[ACPI_SIG_SIZE];
 
-        acpimp_table_sig(table, sig);
-        printf("acpimp: table %s: invalid checksum\n", sig);
+        acpi_table_sig(table, sig);
+        printf("acpi: table %s: invalid checksum\n", sig);
         copy = NULL;
         goto out;
     }
@@ -394,7 +394,7 @@ acpimp_copy_table(uint32_t addr)
     copy = kmem_alloc(size);
 
     if (copy == NULL) {
-        panic("acpimp: unable to allocate memory for acpi data copy");
+        panic("acpi: unable to allocate memory for acpi data copy");
     }
 
     memcpy(copy, table, size);
@@ -405,35 +405,35 @@ out:
 }
 
 static int __init
-acpimp_copy_tables(const struct acpimp_rsdp *rsdp)
+acpi_copy_tables(const struct acpi_rsdp *rsdp)
 {
-    struct acpimp_rsdt *rsdt;
-    struct acpimp_sdth *table;
+    struct acpi_rsdt *rsdt;
+    struct acpi_sdth *table;
     uint32_t *addr, *end;
     int error;
 
-    table = acpimp_copy_table(rsdp->rsdt_address);
+    table = acpi_copy_table(rsdp->rsdt_address);
 
     if (table == NULL) {
         return -1;
     }
 
-    acpimp_register_table(table);
+    acpi_register_table(table);
 
-    rsdt = structof(table, struct acpimp_rsdt, header);
+    rsdt = structof(table, struct acpi_rsdt, header);
     end = (void *)rsdt + rsdt->header.length;
 
     for (addr = rsdt->entries; addr < end; addr++) {
-        table = acpimp_copy_table(*addr);
+        table = acpi_copy_table(*addr);
 
         if (table == NULL) {
             continue;
         }
 
-        acpimp_register_table(table);
+        acpi_register_table(table);
     }
 
-    error = acpimp_check_tables();
+    error = acpi_check_tables();
 
     if (error) {
         goto error;
@@ -442,34 +442,34 @@ acpimp_copy_tables(const struct acpimp_rsdp *rsdp)
     return 0;
 
 error:
-    acpimp_free_tables();
+    acpi_free_tables();
     return -1;
 }
 
 static void __init
-acpimp_madt_iter_init(struct acpimp_madt_iter *iter,
-                      const struct acpimp_madt *madt)
+acpi_madt_iter_init(struct acpi_madt_iter *iter,
+                      const struct acpi_madt *madt)
 {
     iter->entry = madt->entries;
     iter->end = (void *)madt + madt->header.length;
 }
 
 static int __init
-acpimp_madt_iter_valid(const struct acpimp_madt_iter *iter)
+acpi_madt_iter_valid(const struct acpi_madt_iter *iter)
 {
     return iter->entry < iter->end;
 }
 
 static void __init
-acpimp_madt_iter_next(struct acpimp_madt_iter *iter)
+acpi_madt_iter_next(struct acpi_madt_iter *iter)
 {
     iter->entry = (void *)iter->entry + iter->entry->header.length;
 }
 
 static void __init
-acpimp_load_lapic(const struct acpimp_madt_entry_lapic *lapic, int *is_bsp)
+acpi_load_lapic(const struct acpi_madt_entry_lapic *lapic, int *is_bsp)
 {
-    if (!(lapic->flags & ACPIMP_MADT_LAPIC_ENABLED)) {
+    if (!(lapic->flags & ACPI_MADT_LAPIC_ENABLED)) {
         return;
     }
 
@@ -478,22 +478,22 @@ acpimp_load_lapic(const struct acpimp_madt_entry_lapic *lapic, int *is_bsp)
 }
 
 static void __init
-acpimp_load_ioapic(const struct acpimp_madt_entry_ioapic *ioapic)
+acpi_load_ioapic(const struct acpi_madt_entry_ioapic *ioapic)
 {
     ioapic_register(ioapic->id, ioapic->addr, ioapic->base);
 }
 
 static void __init
-acpimp_load_madt(void)
+acpi_load_madt(void)
 {
-    const struct acpimp_sdth *table;
-    const struct acpimp_madt *madt;
-    struct acpimp_madt_iter iter;
+    const struct acpi_sdth *table;
+    const struct acpi_madt *madt;
+    struct acpi_madt_iter iter;
     int is_bsp;
 
-    table = acpimp_lookup_table("APIC");
+    table = acpi_lookup_table("APIC");
     assert(table != NULL);
-    madt = structof(table, struct acpimp_madt, header);
+    madt = structof(table, struct acpi_madt, header);
     lapic_setup(madt->lapic_addr);
     is_bsp = 1;
 
@@ -502,37 +502,37 @@ acpimp_load_madt(void)
      * TODO Handle interrupt overrides
      */
 
-    acpimp_madt_foreach(madt, &iter) {
+    acpi_madt_foreach(madt, &iter) {
         switch (iter.entry->type) {
-        case ACPIMP_MADT_ENTRY_LAPIC:
-            acpimp_load_lapic(&iter.entry->lapic, &is_bsp);
+        case ACPI_MADT_ENTRY_LAPIC:
+            acpi_load_lapic(&iter.entry->lapic, &is_bsp);
             break;
-        case ACPIMP_MADT_ENTRY_IOAPIC:
-            acpimp_load_ioapic(&iter.entry->ioapic);
+        case ACPI_MADT_ENTRY_IOAPIC:
+            acpi_load_ioapic(&iter.entry->ioapic);
         }
     }
 }
 
 int __init
-acpimp_setup(void)
+acpi_setup(void)
 {
-    struct acpimp_rsdp rsdp;
+    struct acpi_rsdp rsdp;
     int error;
 
-    error = acpimp_find_rsdp(&rsdp);
+    error = acpi_find_rsdp(&rsdp);
 
     if (error) {
         return error;
     }
 
-    error = acpimp_copy_tables(&rsdp);
+    error = acpi_copy_tables(&rsdp);
 
     if (error) {
         return error;
     }
 
-    acpimp_info();
-    acpimp_load_madt();
-    acpimp_free_tables();
+    acpi_info();
+    acpi_load_madt();
+    acpi_free_tables();
     return 0;
 }
diff --git a/arch/x86/machine/acpimp.h b/arch/x86/machine/acpi.h
index e66a87a..b767b9a 100644
--- a/arch/x86/machine/acpimp.h
+++ b/arch/x86/machine/acpi.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Richard Braun.
+ * Copyright (c) 2012-2017 Richard Braun.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,15 +19,15 @@
  * specification v1.0.
  */
 
-#ifndef _X86_ACPIMP_H
-#define _X86_ACPIMP_H
+#ifndef _X86_ACPI_H
+#define _X86_ACPI_H
 
 /*
- * Load multiprocessor information.
+ * Load ACPI information.
  *
  * Return 0 if successful (an error usually means hardware doesn't support
  * ACPI).
  */
-int acpimp_setup(void);
+int acpi_setup(void);
 
-#endif /* _X86_ACPIMP_H */
+#endif /* _X86_ACPI_H */
diff --git a/arch/x86/machine/cpu.c b/arch/x86/machine/cpu.c
index 7c60849..7684f56 100644
--- a/arch/x86/machine/cpu.c
+++ b/arch/x86/machine/cpu.c
@@ -28,7 +28,7 @@
 #include <kern/percpu.h>
 #include <kern/thread.h>
 #include <kern/xcall.h>
-#include <machine/acpimp.h>
+#include <machine/acpi.h>
 #include <machine/biosmem.h>
 #include <machine/boot.h>
 #include <machine/cpu.h>
@@ -643,7 +643,7 @@ cpu_mp_probe(void)
 {
     int error;
 
-    error = acpimp_setup();
+    error = acpi_setup();
 
     if (error) {
         /*