os-k/kaleid/kernel/io/acpi.c

288 lines
8.1 KiB
C
Raw Normal View History

2020-02-02 13:33:57 +01:00
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: ACPI, Hardware detection related functions //
// //
// //
// Copyright © 2018-2020 The OS/K Team //
2020-02-02 13:33:57 +01:00
// //
// 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>
2020-02-03 11:58:34 +01:00
#include <io/acpi.h>
2020-02-03 15:34:20 +01:00
#include <mm/paging.h>
2020-02-04 17:23:05 +01:00
#include <mm/map.h>
2020-02-03 15:34:20 +01:00
2020-02-03 17:43:05 +01:00
char IoACPIVersion = 1;
2020-02-04 00:41:41 +01:00
int tableCount = 1;
2020-02-03 17:43:05 +01:00
2020-02-04 17:23:05 +01:00
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"
};
// ACPI Tables Directory
static SDTHeader *SDTDirectory[N_SDT_TYPES] = {0};
2020-02-03 17:43:05 +01:00
//
// Returns the checksum of the given structure
//
2020-02-04 17:23:05 +01:00
static char DoChecksum(const void *ptr, const size_t size,
2020-02-03 15:34:20 +01:00
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;
}
2020-02-02 13:33:57 +01:00
2020-02-03 17:43:05 +01:00
//
// Returns the address of the RSDP
//
static inline RSDPDescriptor *IoFindRSDP()
2020-02-03 11:58:34 +01:00
{
char *rsdp = NULL;
// Search in EBDA
for (rsdp = (char *)0x00080000; // EBDA address
(ulong)rsdp < (ulong)0x0009FFFF; // EBDA end
rsdp++) {
2020-02-08 12:19:40 +01:00
if (!strncmp(rsdp, "RSD PTR", 6)) {
2020-02-03 11:58:34 +01:00
return (RSDPDescriptor *)rsdp;
}
}
// Search in BDA
for (rsdp = (char *)0x000E0000; // BDA address
(ulong)rsdp < (ulong)0x000FFFFF; // BDA end
rsdp++) {
2020-02-08 12:19:40 +01:00
if (!strncmp(rsdp, "RSD PTR", 6)) {
2020-02-03 11:58:34 +01:00
return (RSDPDescriptor *)rsdp;
}
}
return NULL;
}
2020-02-03 17:43:05 +01:00
2020-02-04 00:41:41 +01:00
//
// RSDP Exploration
//
static inline void IoInitRSDP(void)
{
char checksum = 1;
RSDPDescriptor *rsdp = IoFindRSDP();
if (!rsdp)
KeStartPanic("ACPI RSDP not found in memory");
// Checksum calculation
checksum = DoChecksum(rsdp, (size_t)sizeof(RSDPDescriptor),
(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);
2020-02-06 13:18:22 +01:00
DebugLog("ACPI Revision %d (OEM %s)\n",
2020-02-04 00:41:41 +01:00
(uint)rsdp->legacy.revision,
rsdp->legacy.OEMID
);
2020-02-08 12:19:40 +01:00
SDTDirectory[SDT_RSDT] = (void *)(ulong)rsdp->legacy.rsdtAddress;
2020-02-04 00:41:41 +01:00
if (rsdp->legacy.revision) {
2020-02-08 12:19:40 +01:00
SDTDirectory[SDT_XSDT] = (void *)rsdp->xsdtAddress;
2020-02-04 00:41:41 +01:00
IoACPIVersion = 2;
}
}
2020-02-03 17:43:05 +01:00
//
// R/XSDT Exploration
//
static inline void IoInitRXSDT(void)
{
char checksum = 1;
2020-02-08 12:19:40 +01:00
SDTHeader *rxsdt = SDTDirectory[SDT_RSDT];
if (IoACPIVersion == 2) {
rxsdt = SDTDirectory[SDT_XSDT];
}
2020-02-03 17:43:05 +01:00
2020-02-04 17:23:05 +01:00
/* // Checksum calculation */
2020-02-03 17:43:05 +01:00
checksum = DoChecksum(rxsdt, (size_t)rxsdt->length,
0,
0
);
if (checksum)
KeStartPanic("Invalid RSDT checksum : %d vs 0", checksum);
if (IoACPIVersion == 1) {
2020-02-06 13:18:22 +01:00
DebugLog("ACPI Root System Table %s (%s) length %d [%p]\n",
2020-02-03 17:43:05 +01:00
rxsdt->signature,
rxsdt->OEMID,
rxsdt->length,
rxsdt
);
} else {
2020-02-06 13:18:22 +01:00
DebugLog("ACPI Extended System Table %s (%s) length %d [%p]\n",
2020-02-03 17:43:05 +01:00
rxsdt->signature,
rxsdt->OEMID,
rxsdt->length,
rxsdt
);
}
}
//
// Explore all ACPI Tables
//
static inline void IoSearchAcpiTables(void)
{
2020-02-08 12:19:40 +01:00
SDTHeader *xrsdt = SDTDirectory[SDT_RSDT];
2020-02-04 17:23:05 +01:00
SDTHeader *table = NULL;
2020-02-06 08:59:34 +01:00
uint *curInt = NULL;
ulong *curLong = NULL;
2020-02-04 17:23:05 +01:00
register char checksum;
int entries;
2020-02-06 08:59:34 +01:00
if (IoACPIVersion == 1) {
2020-02-04 17:23:05 +01:00
entries = (xrsdt->length - sizeof(xrsdt)) / 4;
2020-02-06 08:59:34 +01:00
} else {
2020-02-08 12:19:40 +01:00
xrsdt = SDTDirectory[SDT_XSDT];
2020-02-04 17:23:05 +01:00
entries = (xrsdt->length - sizeof(xrsdt)) / 8;
2020-02-06 08:59:34 +01:00
}
2020-02-04 17:23:05 +01:00
2020-02-06 13:18:22 +01:00
DebugLog("ACPI detected %d entries\n", entries);
2020-02-04 17:23:05 +01:00
curInt = (uint*)&(xrsdt->sdtTablePtr);
curLong = (ulong*)&(xrsdt->sdtTablePtr);
2020-02-04 17:23:05 +01:00
2020-02-06 08:59:34 +01:00
for (int i = 0; i < entries; i++) {
2020-02-04 17:23:05 +01:00
2020-02-06 08:59:34 +01:00
if (IoACPIVersion == 1)
table = (SDTHeader *)(ulong)curInt[i];
2020-02-06 08:59:34 +01:00
else
table = (SDTHeader *)(ulong)curLong[i];
2020-02-06 08:59:34 +01:00
//KernLog("\tACPI RSDT[%d] %p\n", i, table);
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], 3)) {
DebugLog("ACPI System Table %s (OEM %s) length %d [%p]\n",
SDTChar[i],
table->OEMID,
table->length,
table
);
SDTDirectory[i] = table;
}
}
2020-02-06 08:59:34 +01:00
}
}
2020-02-04 17:23:05 +01:00
}
2020-02-03 17:43:05 +01:00
}
2020-02-04 00:41:41 +01:00
// -------------------------------------------------------------------------- //
2020-02-03 17:43:05 +01:00
//
// Initialise the ACPI by finding tables
//
void IoInitAcpi(void)
{
2020-02-04 17:23:05 +01:00
// MAP ACPI PAGES
// Search the zone where the start address is
for (uint i = 0; i < memoryMap.length; i++) {
// if the address is in an available zone, we can return the length
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);
}
}
}
2020-02-03 17:43:05 +01:00
2020-02-04 17:23:05 +01:00
// FIND RSDP
2020-02-03 17:43:05 +01:00
IoInitRSDP();
IoInitRXSDT();
2020-02-04 17:23:05 +01:00
IoSearchAcpiTables();
2020-02-03 17:43:05 +01:00
}
//
// Returns the addr of the submitted SDT
//
// Arg must be a member of the enum in acpi.h
//
SDTHeader *IoGetAcpiTable(ulong id)
{
return SDTDirectory[id];
}