mirror of
https://gitlab.os-k.eu/os-k-team/os-k.git
synced 2023-08-25 14:03:10 +02:00
307 lines
8.6 KiB
C
307 lines
8.6 KiB
C
//----------------------------------------------------------------------------//
|
|
// OS on Kaleid //
|
|
// //
|
|
// Desc: ACPI, Hardware detection related functions //
|
|
// //
|
|
// //
|
|
// Copyright © 2018-2021 The OS/K Team //
|
|
// //
|
|
// This file is part of OS/K. //
|
|
// //
|
|
// OS/K is free software: you can redistribute it and/or modify //
|
|
// it under the terms of the GNU General Public License as published by //
|
|
// the Free Software Foundation, either version 3 of the License, or //
|
|
// any later version. //
|
|
// //
|
|
// OS/K is distributed in the hope that it will be useful, //
|
|
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
|
// GNU General Public License for more details. //
|
|
// //
|
|
// You should have received a copy of the GNU General Public License //
|
|
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
#include <init/boot.h>
|
|
#include <io/vga.h>
|
|
#include <io/acpi.h>
|
|
#include <mm/paging.h>
|
|
#include <mm/map.h>
|
|
|
|
char IoACPIVersion = 1;
|
|
int tableCount = 1;
|
|
|
|
extern MemoryMap_t memoryMap;
|
|
|
|
// ACPI reverse strings
|
|
static char *SDTChar[N_SDT_TYPES] = {
|
|
"APIC",
|
|
"BERT",
|
|
"CPEP",
|
|
"DSDT",
|
|
"ECDT",
|
|
"EINJ",
|
|
"ERST",
|
|
"FACP",
|
|
"FACS",
|
|
"HEST",
|
|
"MSCT",
|
|
"MPST",
|
|
"OEMx",
|
|
"PMTT",
|
|
"PSDT",
|
|
"RASF",
|
|
"RSDT",
|
|
"SBST",
|
|
"SLIT",
|
|
"SRAT",
|
|
"SSDT",
|
|
"XSDT",
|
|
"HPET",
|
|
"MCFG"
|
|
};
|
|
|
|
// ACPI Tables Directory
|
|
static SDTHeader_t *SDTDirectory[N_SDT_TYPES] = {0};
|
|
|
|
//
|
|
// Returns the checksum of the given structure
|
|
//
|
|
static char DoChecksum(const void *ptr, const size_t size,
|
|
size_t intermediateSize, ulong reason)
|
|
{
|
|
char checksum = 0;
|
|
for (ulong i=0; i < (ulong)size; i++) {
|
|
if (reason && i > (ulong)intermediateSize)
|
|
break;
|
|
checksum += (uchar)((char*)ptr)[i];
|
|
}
|
|
return checksum;
|
|
}
|
|
|
|
//
|
|
// Returns the address of the RSDP
|
|
//
|
|
static inline RSDPDescriptor_t *IoFindRSDP()
|
|
{
|
|
char *rsdp = NULL;
|
|
|
|
|
|
// Search in EBDA
|
|
for (rsdp = (char *)0x00080000; // EBDA address
|
|
(ulong)rsdp < (ulong)0x0009FFFF; // EBDA end
|
|
rsdp++) {
|
|
|
|
if (!strncmp(rsdp, "RSD PTR", 7)) {
|
|
return (RSDPDescriptor_t *)rsdp;
|
|
}
|
|
}
|
|
|
|
// Search in BDA
|
|
for (rsdp = (char *)0x000E0000; // BDA address
|
|
(ulong)rsdp < (ulong)0x000FFFFF; // BDA end
|
|
rsdp++) {
|
|
|
|
if (!strncmp(rsdp, "RSD PTR", 7)) {
|
|
return (RSDPDescriptor_t *)rsdp;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// RSDP Exploration
|
|
//
|
|
static inline void IoInitRSDP(void)
|
|
{
|
|
char checksum = 1;
|
|
|
|
RSDPDescriptor_t *rsdp = IoFindRSDP();
|
|
if (!rsdp)
|
|
KeStartPanic("ACPI RSDP not found in memory");
|
|
|
|
// Checksum calculation
|
|
checksum = DoChecksum(rsdp, (size_t)sizeof(RSDPDescriptor_t),
|
|
(size_t)sizeof(struct RSDPLegacy),
|
|
!rsdp->legacy.revision
|
|
);
|
|
|
|
if (checksum)
|
|
KeStartPanic("Invalid RSDP checksum : %d vs 0", checksum);
|
|
|
|
if (rsdp->legacy.revision == 1 || rsdp->legacy.revision >= 3)
|
|
KeStartPanic("Invalid ACPI Revision : %d", rsdp->legacy.revision);
|
|
|
|
DebugLog("ACPI Revision %d (OEM %s)\n",
|
|
(uint)rsdp->legacy.revision,
|
|
rsdp->legacy.OEMID
|
|
);
|
|
|
|
SDTDirectory[SDT_RSDT] = (void *)(ulong)rsdp->legacy.rsdtAddress;
|
|
|
|
if (rsdp->legacy.revision) {
|
|
SDTDirectory[SDT_XSDT] = (void *)rsdp->xsdtAddress;
|
|
IoACPIVersion = 2;
|
|
}
|
|
}
|
|
|
|
//
|
|
// R/XSDT Exploration
|
|
//
|
|
static inline void IoInitRXSDT(void)
|
|
{
|
|
char checksum = 1;
|
|
|
|
SDTHeader_t *rxsdt = SDTDirectory[SDT_RSDT];
|
|
|
|
if (IoACPIVersion == 2) {
|
|
rxsdt = SDTDirectory[SDT_XSDT];
|
|
}
|
|
|
|
/* // Checksum calculation */
|
|
checksum = DoChecksum(rxsdt, (size_t)rxsdt->length,
|
|
0,
|
|
0
|
|
);
|
|
|
|
if (checksum)
|
|
KeStartPanic("Invalid RSDT checksum : %d vs 0", checksum);
|
|
|
|
if (IoACPIVersion == 1) {
|
|
DebugLog("ACPI Root System Table %s length %d [%p]\n",
|
|
rxsdt->signature,
|
|
rxsdt->length,
|
|
rxsdt
|
|
);
|
|
} else {
|
|
DebugLog("ACPI Extended System Table %s length %d [%p]\n",
|
|
rxsdt->signature,
|
|
rxsdt->length,
|
|
rxsdt
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Explore all ACPI Tables
|
|
//
|
|
static inline void IoSearchAcpiTables(void)
|
|
{
|
|
SDTHeader_t *xrsdt = SDTDirectory[SDT_RSDT];
|
|
SDTHeader_t *table = NULL;
|
|
uint *curInt = NULL;
|
|
ulong *curLong = NULL;
|
|
register char checksum;
|
|
int entries;
|
|
|
|
if (IoACPIVersion == 1) {
|
|
entries = (xrsdt->length - sizeof(xrsdt)) / 4;
|
|
} else {
|
|
xrsdt = SDTDirectory[SDT_XSDT];
|
|
entries = (xrsdt->length - sizeof(xrsdt)) / 8;
|
|
}
|
|
|
|
DebugLog("ACPI detected %d entries\n", entries);
|
|
|
|
curInt = (uint*)&(xrsdt->sdtEntry);
|
|
curLong = (ulong*)&(xrsdt->sdtEntry);
|
|
|
|
// Parsing R/XSDT
|
|
for (int i = 0; i < entries; i++) {
|
|
|
|
if (IoACPIVersion == 1)
|
|
table = (SDTHeader_t *)(ulong)curInt[i];
|
|
else
|
|
table = (SDTHeader_t *)(ulong)curLong[i];
|
|
|
|
if (MmIsBusyZone(table)) {
|
|
checksum = DoChecksum(table, (size_t)table->length, 0, 0);
|
|
if (!checksum) {
|
|
for (ulong i=0; i < N_SDT_TYPES; i++) {
|
|
if (!strncmp(table->signature, SDTChar[i], 4)) {
|
|
DebugLog("ACPI System Table %s length %d [%p]\n",
|
|
SDTChar[i],
|
|
table->length,
|
|
table
|
|
);
|
|
SDTDirectory[i] = table;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Parsing FADT
|
|
FADT_t *fadt = (FADT_t *)IoGetAcpiTable(SDT_FADT);
|
|
SDTHeader_t *dsdt;
|
|
|
|
if (IoACPIVersion == 1) {
|
|
dsdt = (SDTHeader_t *)(ulong)fadt->dsdtAddress;
|
|
} else {
|
|
dsdt = (SDTHeader_t *)(ulong)fadt->xDsdtAddress;
|
|
}
|
|
|
|
checksum = DoChecksum(dsdt, (size_t)dsdt->length, 0, 0);
|
|
if (!checksum) {
|
|
if (!strncmp(dsdt->signature, SDTChar[SDT_DSDT], 4)) {
|
|
DebugLog("ACPI System Table %s length %d [%p]\n",
|
|
SDTChar[SDT_DSDT],
|
|
dsdt->length,
|
|
dsdt
|
|
);
|
|
SDTDirectory[SDT_DSDT] = dsdt;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
|
|
//
|
|
// Initialise the ACPI by finding tables
|
|
//
|
|
void IoInitAcpi(void)
|
|
{
|
|
// MAP ACPI PAGES
|
|
|
|
for (uint i = 0; i < memoryMap.length; i++) {
|
|
if (memoryMap.entry[i].type != AVAILABLE_ZONE) {
|
|
|
|
// Map each page that is in the busy zone
|
|
for (uint j = 0;
|
|
j < (memoryMap.entry[i].length
|
|
+ ((ulong)memoryMap.entry[i].addr)
|
|
- ((ulong)memoryMap.entry[i].addr
|
|
& 0xFFFFFFFFFFFFF000))
|
|
/ KPAGESIZE;
|
|
j++) {
|
|
MmMapPage(memoryMap.entry[i].addr + KPAGESIZE*j,
|
|
memoryMap.entry[i].addr + KPAGESIZE*j,
|
|
PRESENT);
|
|
//KernLog("ACPI %d ID MAP %p\n", i,
|
|
// memoryMap.entry[i].addr + KPAGESIZE*j);
|
|
}
|
|
}
|
|
}
|
|
|
|
// FIND RSDP
|
|
IoInitRSDP();
|
|
|
|
IoInitRXSDT();
|
|
|
|
IoSearchAcpiTables();
|
|
}
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
|
|
//
|
|
// Returns the addr of the submitted SDT
|
|
//
|
|
// Arg must be a member of the enum in acpi.h
|
|
//
|
|
SDTHeader_t *IoGetAcpiTable(ulong id)
|
|
{
|
|
return SDTDirectory[id];
|
|
}
|