kernel/lib/acpi_lite/acpi_lite.cpp - zircon - Git at Google

 // Copyright 2018 The Fuchsia Authors
 //
 // 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

 #include <lib/acpi_lite.h>

 #include <inttypes.h>
 #include <zircon/compiler.h>
 #include <trace.h>
 #include <vm/physmap.h>

 #define LOCAL_TRACE 1

 // global state of the acpi lite library
 struct acpi_lite_state {
     const acpi_rsdp *rsdp;
     const acpi_rsdt_xsdt *sdt;
     size_t num_tables; // number of top level tables
     bool xsdt; // are the pointers 64 or 32bit?
 } acpi;

 static inline const void *phys_to_ptr(uintptr_t pa) {
     if (!is_physmap_phys_addr(pa)) {
         return nullptr;
     }
     // consider 0 to be invalid
     if (pa == 0) {
         return nullptr;
     }

     return static_cast<const void *>(paddr_to_physmap(pa));
 }

 static uint8_t acpi_checksum(const void *_buf, size_t len) {
     uint8_t c = 0;

     const uint8_t *buf = static_cast<const uint8_t *>(_buf);
     for (size_t i = 0; i < len; i++) {
         c = (uint8_t)(c + buf[i]);
     }

     return c;
 }

 static bool validate_rsdp(const acpi_rsdp *rsdp) {
     // check the signature
     if (memcmp(ACPI_RSDP_SIG, rsdp->sig, 8)) {
         return false;
     }

     // validate the v1 checksum on the first 20 bytes of the table
     uint8_t c = acpi_checksum(rsdp, 20);
     if (c) {
         return false;
     }

     // is it v2?
     if (rsdp->revision >= 2) {
         if (rsdp->length < 36 || rsdp->length > 4096) {
             // keep the table length within reason
             return false;
         }

         c = acpi_checksum(rsdp, rsdp->length);
         if (c) {
             return false;
         }
     }

     // seems okay
     return true;
 }

 static zx_paddr_t find_rsdp_pc() {
     // search for it in the BIOS EBDA area (0xe0000..0xfffff) on 16 byte boundaries
     for (zx_paddr_t ptr = 0xe0000; ptr <= 0xfffff; ptr += 16) {
         const auto rsdp = static_cast<const acpi_rsdp *>(phys_to_ptr(ptr));

         if (validate_rsdp(rsdp)) {
             return ptr;
         }
     }

     return 0;
 }

 static bool validate_sdt(const acpi_rsdt_xsdt *sdt, size_t *num_tables, bool *xsdt) {
     LTRACEF("%p\n", sdt);

     // check the signature and see if it's a rsdt or xsdt
     if (!memcmp(sdt->header.sig, "XSDT", 4)) {
         *xsdt = true;
     } else if (!memcmp(sdt->header.sig, "RSDT", 4)) {
         *xsdt = false;
     } else {
         return false;
     }

     // is the length sane?
     if (sdt->header.length < 36 || sdt->header.length > 4096) {
         return false;
     }

     // is it a revision we understand?
     if (sdt->header.revision != 1) {
         return false;
     }

     // checksum the entire table
     uint8_t c = acpi_checksum(sdt, sdt->header.length);
     if (c) {
         return false;
     }

     // compute the number of pointers to tables we have
     *num_tables = (sdt->header.length - 36u) / (*xsdt ? 8u : 4u);

     // looks okay
     return true;
 }

 const acpi_sdt_header *acpi_get_table_at_index(size_t index) {
     if (index >= acpi.num_tables) {
         return nullptr;
     }

     zx_paddr_t pa;
     if (acpi.xsdt) {
         pa = acpi.sdt->addr64[index];
     } else {
         pa = acpi.sdt->addr32[index];
     }

     return static_cast<const acpi_sdt_header *>(phys_to_ptr(pa));
 }

 const acpi_sdt_header *acpi_get_table_by_sig(const char *sig) {
     // walk the list of tables
     for (size_t i = 0; i < acpi.num_tables; i++) {
         const auto header = acpi_get_table_at_index(i);
         if (!header) {
             continue;
         }

         if (!memcmp(sig, header->sig, 4)) {
             // validate the checksum
             uint8_t c = acpi_checksum(header, header->length);
             if (c == 0) {
                 return header;
             }
         }
     }

     return nullptr;
 }

 zx_status_t acpi_lite_init(zx_paddr_t rsdp_pa) {
     LTRACEF("passed in rsdp %#" PRIxPTR "\n", rsdp_pa);

     // see if the rsdp pointer is valid
     if (rsdp_pa == 0) {
         // search around for it in a platform-specific way
 #if PLATFORM_PC
         rsdp_pa = find_rsdp_pc();
         if (rsdp_pa == 0) {
             dprintf(INFO, "ACPI LITE: couldn't find ACPI RSDP in BIOS area\n");
         }
 #endif

         if (rsdp_pa == 0) {
             return ZX_ERR_NOT_FOUND;
         }
     }

     const void *ptr = phys_to_ptr(rsdp_pa);
     if (!ptr) {
         dprintf(INFO, "ACPI LITE: failed to translate RSDP address %#" PRIxPTR " to virtual\n", rsdp_pa);
         return ZX_ERR_NOT_FOUND;
     }

     // see if the RSDP is there
     acpi.rsdp = static_cast<const acpi_rsdp *>(ptr);
     if (!validate_rsdp(acpi.rsdp)) {
         dprintf(INFO, "ACPI LITE: RSDP structure does not check out\n");
         return ZX_ERR_NOT_FOUND;
     }

     dprintf(SPEW, "ACPI LITE: RSDP checks out\n");

     // find the pointer to either the RSDT or XSDT
     acpi.sdt = nullptr;
     if (acpi.rsdp->revision < 2) {
         // v1 RSDP, pointing at a RSDT
         acpi.sdt = static_cast<const acpi_rsdt_xsdt *>(phys_to_ptr(acpi.rsdp->rsdt_address));
     } else {
         // v2+ RSDP, pointing at a XSDT
         // try to use the 64bit address first
         acpi.sdt = static_cast<const acpi_rsdt_xsdt *>(phys_to_ptr(acpi.rsdp->xsdt_address));
         if (!acpi.sdt) {
             acpi.sdt = static_cast<const acpi_rsdt_xsdt *>(phys_to_ptr(acpi.rsdp->rsdt_address));
         }
     }

     if (!validate_sdt(acpi.sdt, &acpi.num_tables, &acpi.xsdt)) {
         dprintf(INFO, "ACPI LITE: RSDT/XSDT structure does not check out\n");
         return ZX_ERR_NOT_FOUND;
     }

     dprintf(SPEW, "ACPI LITE: RSDT/XSDT checks out, %zu tables\n", acpi.num_tables);

     acpi_lite_dump_tables();

     return ZX_OK;
 }

 void acpi_lite_dump_tables() {
     if (!acpi.sdt) {
         return;
     }

     //printf("root table:\n");
     //hexdump(acpi.sdt, acpi.sdt->header.length);

     // walk the table list
     for (size_t i = 0; i < acpi.num_tables; i++) {
         const auto header = acpi_get_table_at_index(i);
         if (!header) {
             continue;
         }

         printf("table %zu: '%c%c%c%c' len %u\n", i, header->sig[0], header->sig[1],
                header->sig[2], header->sig[3], header->length);
         //hexdump(header, header->length);
     }
 }

 zx_status_t acpi_process_madt_entries_etc(const uint8_t search_type, const MadtEntryCallback& callback) {
     const acpi_madt_table *madt = reinterpret_cast<const acpi_madt_table *>(acpi_get_table_by_sig(ACPI_MADT_SIG));
     if (!madt) {
         return ZX_ERR_NOT_FOUND;
     }

     // bytewise array of the same table
     const uint8_t *madt_array = reinterpret_cast<const uint8_t *>(madt);

     // walk the table off the end of the header, looking for the requested type
     size_t off = sizeof(*madt);
     while (off < madt->header.length) {
         uint8_t type = madt_array[off];
         uint8_t length = madt_array[off + 1];

         if (type == search_type) {
             callback(static_cast<const void *>(&madt_array[off]) , length);
         }

         off += length;
     }

     return ZX_OK;
 }
	// Copyright 2018 The Fuchsia Authors
	//
	// 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

	#include <lib/acpi_lite.h>

	#include <inttypes.h>
	#include <zircon/compiler.h>
	#include <trace.h>
	#include <vm/physmap.h>

	#define LOCAL_TRACE 1

	// global state of the acpi lite library
	struct acpi_lite_state {
	const acpi_rsdp *rsdp;
	const acpi_rsdt_xsdt *sdt;
	size_t num_tables; // number of top level tables
	bool xsdt; // are the pointers 64 or 32bit?
	} acpi;

	static inline const void *phys_to_ptr(uintptr_t pa) {
	if (!is_physmap_phys_addr(pa)) {
	return nullptr;
	}
	// consider 0 to be invalid
	if (pa == 0) {
	return nullptr;
	}

	return static_cast<const void *>(paddr_to_physmap(pa));
	}

	static uint8_t acpi_checksum(const void *_buf, size_t len) {
	uint8_t c = 0;

	const uint8_t buf = static_cast<const uint8_t >(_buf);
	for (size_t i = 0; i < len; i++) {
	c = (uint8_t)(c + buf[i]);
	}

	return c;
	}

	static bool validate_rsdp(const acpi_rsdp *rsdp) {
	// check the signature
	if (memcmp(ACPI_RSDP_SIG, rsdp->sig, 8)) {
	return false;
	}

	// validate the v1 checksum on the first 20 bytes of the table
	uint8_t c = acpi_checksum(rsdp, 20);
	if (c) {
	return false;
	}

	// is it v2?
	if (rsdp->revision >= 2) {
	if (rsdp->length < 36 \|\| rsdp->length > 4096) {
	// keep the table length within reason
	return false;
	}

	c = acpi_checksum(rsdp, rsdp->length);
	if (c) {
	return false;
	}
	}

	// seems okay
	return true;
	}

	static zx_paddr_t find_rsdp_pc() {
	// search for it in the BIOS EBDA area (0xe0000..0xfffff) on 16 byte boundaries
	for (zx_paddr_t ptr = 0xe0000; ptr <= 0xfffff; ptr += 16) {
	const auto rsdp = static_cast<const acpi_rsdp *>(phys_to_ptr(ptr));

	if (validate_rsdp(rsdp)) {
	return ptr;
	}
	}

	return 0;
	}

	static bool validate_sdt(const acpi_rsdt_xsdt sdt, size_t num_tables, bool *xsdt) {
	LTRACEF("%p\n", sdt);

	// check the signature and see if it's a rsdt or xsdt
	if (!memcmp(sdt->header.sig, "XSDT", 4)) {
	*xsdt = true;
	} else if (!memcmp(sdt->header.sig, "RSDT", 4)) {
	*xsdt = false;
	} else {
	return false;
	}

	// is the length sane?
	if (sdt->header.length < 36 \|\| sdt->header.length > 4096) {
	return false;
	}

	// is it a revision we understand?
	if (sdt->header.revision != 1) {
	return false;
	}

	// checksum the entire table
	uint8_t c = acpi_checksum(sdt, sdt->header.length);
	if (c) {
	return false;
	}

	// compute the number of pointers to tables we have
	num_tables = (sdt->header.length - 36u) / (xsdt ? 8u : 4u);

	// looks okay
	return true;
	}

	const acpi_sdt_header *acpi_get_table_at_index(size_t index) {
	if (index >= acpi.num_tables) {
	return nullptr;
	}

	zx_paddr_t pa;
	if (acpi.xsdt) {
	pa = acpi.sdt->addr64[index];
	} else {
	pa = acpi.sdt->addr32[index];
	}

	return static_cast<const acpi_sdt_header *>(phys_to_ptr(pa));
	}

	const acpi_sdt_header acpi_get_table_by_sig(const char sig) {
	// walk the list of tables
	for (size_t i = 0; i < acpi.num_tables; i++) {
	const auto header = acpi_get_table_at_index(i);
	if (!header) {
	continue;
	}

	if (!memcmp(sig, header->sig, 4)) {
	// validate the checksum
	uint8_t c = acpi_checksum(header, header->length);
	if (c == 0) {
	return header;
	}
	}
	}

	return nullptr;
	}

	zx_status_t acpi_lite_init(zx_paddr_t rsdp_pa) {
	LTRACEF("passed in rsdp %#" PRIxPTR "\n", rsdp_pa);

	// see if the rsdp pointer is valid
	if (rsdp_pa == 0) {
	// search around for it in a platform-specific way
	#if PLATFORM_PC
	rsdp_pa = find_rsdp_pc();
	if (rsdp_pa == 0) {
	dprintf(INFO, "ACPI LITE: couldn't find ACPI RSDP in BIOS area\n");
	}
	#endif

	if (rsdp_pa == 0) {
	return ZX_ERR_NOT_FOUND;
	}
	}

	const void *ptr = phys_to_ptr(rsdp_pa);
	if (!ptr) {
	dprintf(INFO, "ACPI LITE: failed to translate RSDP address %#" PRIxPTR " to virtual\n", rsdp_pa);
	return ZX_ERR_NOT_FOUND;
	}

	// see if the RSDP is there
	acpi.rsdp = static_cast<const acpi_rsdp *>(ptr);
	if (!validate_rsdp(acpi.rsdp)) {
	dprintf(INFO, "ACPI LITE: RSDP structure does not check out\n");
	return ZX_ERR_NOT_FOUND;
	}

	dprintf(SPEW, "ACPI LITE: RSDP checks out\n");

	// find the pointer to either the RSDT or XSDT
	acpi.sdt = nullptr;
	if (acpi.rsdp->revision < 2) {
	// v1 RSDP, pointing at a RSDT
	acpi.sdt = static_cast<const acpi_rsdt_xsdt *>(phys_to_ptr(acpi.rsdp->rsdt_address));
	} else {
	// v2+ RSDP, pointing at a XSDT
	// try to use the 64bit address first
	acpi.sdt = static_cast<const acpi_rsdt_xsdt *>(phys_to_ptr(acpi.rsdp->xsdt_address));
	if (!acpi.sdt) {
	acpi.sdt = static_cast<const acpi_rsdt_xsdt *>(phys_to_ptr(acpi.rsdp->rsdt_address));
	}
	}

	if (!validate_sdt(acpi.sdt, &acpi.num_tables, &acpi.xsdt)) {
	dprintf(INFO, "ACPI LITE: RSDT/XSDT structure does not check out\n");
	return ZX_ERR_NOT_FOUND;
	}

	dprintf(SPEW, "ACPI LITE: RSDT/XSDT checks out, %zu tables\n", acpi.num_tables);

	acpi_lite_dump_tables();

	return ZX_OK;
	}

	void acpi_lite_dump_tables() {
	if (!acpi.sdt) {
	return;
	}

	//printf("root table:\n");
	//hexdump(acpi.sdt, acpi.sdt->header.length);

	// walk the table list
	for (size_t i = 0; i < acpi.num_tables; i++) {
	const auto header = acpi_get_table_at_index(i);
	if (!header) {
	continue;
	}

	printf("table %zu: '%c%c%c%c' len %u\n", i, header->sig[0], header->sig[1],
	header->sig[2], header->sig[3], header->length);
	//hexdump(header, header->length);
	}
	}

	zx_status_t acpi_process_madt_entries_etc(const uint8_t search_type, const MadtEntryCallback& callback) {
	const acpi_madt_table madt = reinterpret_cast<const acpi_madt_table >(acpi_get_table_by_sig(ACPI_MADT_SIG));
	if (!madt) {
	return ZX_ERR_NOT_FOUND;
	}

	// bytewise array of the same table
	const uint8_t madt_array = reinterpret_cast<const uint8_t >(madt);

	// walk the table off the end of the header, looking for the requested type
	size_t off = sizeof(*madt);
	while (off < madt->header.length) {
	uint8_t type = madt_array[off];
	uint8_t length = madt_array[off + 1];

	if (type == search_type) {
	callback(static_cast<const void *>(&madt_array[off]) , length);
	}

	off += length;
	}

	return ZX_OK;
	}