235 lines
8.6 KiB
C++
235 lines
8.6 KiB
C++
/*
|
|
* AmlNamespace.hpp
|
|
* AML object types and ACPI namespace tree
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#pragma once
|
|
#include <cstdint>
|
|
#include <Libraries/Memory.hpp>
|
|
|
|
namespace Hal {
|
|
namespace AML {
|
|
|
|
// ============================================================================
|
|
|
|
// AML Object Types
|
|
|
|
// ============================================================================
|
|
enum class ObjectType : uint8_t {
|
|
None = 0,
|
|
Integer,
|
|
String,
|
|
Buffer,
|
|
Package,
|
|
Device,
|
|
Method,
|
|
OperationRegion,
|
|
Field,
|
|
Mutex,
|
|
Processor,
|
|
ThermalZone,
|
|
PowerResource,
|
|
BufferField,
|
|
};
|
|
|
|
// ============================================================================
|
|
|
|
// Region address spaces (OperationRegion)
|
|
|
|
// ============================================================================
|
|
enum class RegionSpace : uint8_t {
|
|
SystemMemory = 0x00,
|
|
SystemIO = 0x01,
|
|
PciConfig = 0x02,
|
|
EmbeddedControl = 0x03,
|
|
SMBus = 0x04,
|
|
CMOS = 0x05,
|
|
PciBarTarget = 0x06,
|
|
};
|
|
|
|
// ============================================================================
|
|
|
|
// Constants
|
|
|
|
// ============================================================================
|
|
static constexpr int MaxNameSegLen = 4;
|
|
static constexpr int MaxPathDepth = 16;
|
|
static constexpr int MaxChildren = 64;
|
|
static constexpr int MaxStringLen = 64;
|
|
static constexpr int MaxBufferLen = 256;
|
|
static constexpr int MaxPackageElements = 16;
|
|
static constexpr int MaxMethodArgs = 7;
|
|
static constexpr int MaxMethodLocals = 8;
|
|
|
|
// Nodes are allocated dynamically in chunks from the kernel heap.
|
|
// Each chunk holds this many nodes; new chunks are allocated on demand.
|
|
static constexpr int NodesPerChunk = 256;
|
|
static constexpr int MaxChunks = 128; // up to 32768 nodes
|
|
|
|
// ============================================================================
|
|
|
|
// AML Object
|
|
|
|
// ============================================================================
|
|
// Tagged union representing any AML value. Kept small for kernel use.
|
|
struct Object {
|
|
ObjectType Type = ObjectType::None;
|
|
|
|
union {
|
|
uint64_t Integer;
|
|
|
|
struct {
|
|
char Data[MaxStringLen];
|
|
uint16_t Length;
|
|
} String;
|
|
|
|
struct {
|
|
uint8_t Data[MaxBufferLen];
|
|
uint32_t Length;
|
|
} Buffer;
|
|
|
|
struct {
|
|
uint8_t ArgCount; // bits 0-2 of method flags
|
|
bool Serialized; // bit 3
|
|
uint32_t AmlOffset; // offset into DSDT AML where the method body starts
|
|
uint32_t AmlLength; // length of the method body
|
|
} Method;
|
|
|
|
struct {
|
|
RegionSpace Space;
|
|
uint64_t Offset;
|
|
uint64_t Length;
|
|
} Region;
|
|
|
|
struct {
|
|
uint32_t RegionNodeIndex; // index of the parent OperationRegion node
|
|
uint32_t BitOffset;
|
|
uint32_t BitLength;
|
|
uint8_t AccessType; // 0=Any, 1=Byte, 2=Word, 3=DWord, 4=QWord, 5=Buffer
|
|
} Field;
|
|
|
|
struct {
|
|
uint8_t ProcId;
|
|
uint32_t PblkAddr;
|
|
uint8_t PblkLen;
|
|
} Processor;
|
|
};
|
|
|
|
Object() : Type(ObjectType::None), Integer(0) {}
|
|
};
|
|
|
|
// ============================================================================
|
|
|
|
// Namespace Node
|
|
|
|
// ============================================================================
|
|
// Each node has a 4-char name segment and an associated object.
|
|
struct NamespaceNode {
|
|
char Name[MaxNameSegLen + 1]; // null-terminated 4-char segment
|
|
Object Obj;
|
|
int32_t ParentIndex; // -1 for root
|
|
int32_t ChildIndices[MaxChildren];
|
|
int32_t ChildCount;
|
|
|
|
void Clear() {
|
|
Name[0] = 0;
|
|
Obj = Object{};
|
|
ParentIndex = -1;
|
|
ChildCount = 0;
|
|
for (int i = 0; i < MaxChildren; i++)
|
|
ChildIndices[i] = -1;
|
|
}
|
|
};
|
|
|
|
// ============================================================================
|
|
|
|
// Namespace
|
|
|
|
// ============================================================================
|
|
// Dynamically-allocated node pool forming a tree via parent/child indices.
|
|
// Nodes are allocated in chunks from the kernel heap on demand.
|
|
class Namespace {
|
|
public:
|
|
Namespace();
|
|
|
|
// Create or find a node at the given absolute path (e.g. "\\_SB_.PCI0").
|
|
// Returns the node index, or -1 on failure.
|
|
int32_t CreateNode(const char* absolutePath);
|
|
|
|
// Find a node by absolute path. Returns index or -1.
|
|
int32_t FindNode(const char* absolutePath) const;
|
|
|
|
// Find a node relative to a scope. Tries:
|
|
// 1. scopePath + name
|
|
// 2. Walk up parent scopes
|
|
// 3. Root scope
|
|
int32_t ResolveName(const char* name, int32_t scopeNodeIndex) const;
|
|
|
|
// Get a node by index.
|
|
NamespaceNode* GetNode(int32_t index);
|
|
const NamespaceNode* GetNode(int32_t index) const;
|
|
|
|
// Get the root node index (always 0).
|
|
int32_t RootIndex() const { return 0; }
|
|
|
|
// Build the absolute path of a node into outBuf. Returns outBuf.
|
|
char* GetNodePath(int32_t index, char* outBuf, int maxLen) const;
|
|
|
|
// Get the number of nodes in the namespace.
|
|
int32_t NodeCount() const { return m_nodeCount; }
|
|
|
|
// Maximum capacity with current chunk limit.
|
|
int32_t MaxCapacity() const { return MaxChunks * NodesPerChunk; }
|
|
|
|
// Iterate children of a node matching a given object type.
|
|
// callback returns true to continue, false to stop.
|
|
// Returns the index of the node that stopped iteration, or -1.
|
|
template<typename Fn>
|
|
int32_t ForEachChild(int32_t parentIndex, ObjectType type, Fn callback) const {
|
|
auto* parent = GetNode(parentIndex);
|
|
if (!parent) return -1;
|
|
for (int32_t i = 0; i < parent->ChildCount; i++) {
|
|
int32_t ci = parent->ChildIndices[i];
|
|
auto* child = GetNode(ci);
|
|
if (!child) continue;
|
|
if (type != ObjectType::None && child->Obj.Type != type) continue;
|
|
if (!callback(ci, child)) return ci;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Recursively find all descendants of a given type.
|
|
template<typename Fn>
|
|
void WalkDescendants(int32_t nodeIndex, ObjectType type, Fn callback) const {
|
|
auto* node = GetNode(nodeIndex);
|
|
if (!node) return;
|
|
for (int32_t i = 0; i < node->ChildCount; i++) {
|
|
int32_t ci = node->ChildIndices[i];
|
|
auto* child = GetNode(ci);
|
|
if (!child) continue;
|
|
if (type == ObjectType::None || child->Obj.Type == type)
|
|
callback(ci, child);
|
|
WalkDescendants(ci, type, callback);
|
|
}
|
|
}
|
|
|
|
private:
|
|
int32_t AllocNode();
|
|
bool AllocChunk();
|
|
void EnsureRoot();
|
|
int32_t FindChildByName(int32_t parentIndex, const char* seg) const;
|
|
|
|
// Parse an absolute path into segments. Returns number of segments.
|
|
static int ParsePath(const char* path, char segments[][MaxNameSegLen + 1], int maxSegments);
|
|
static bool SegmentEqual(const char* a, const char* b);
|
|
static void PadSegment(const char* src, char* dst); // pad to 4 chars with '_'
|
|
|
|
NamespaceNode* m_chunks[MaxChunks]; // array of pointers to heap-allocated chunks
|
|
int32_t m_chunkCount;
|
|
int32_t m_nodeCount;
|
|
};
|
|
|
|
};
|
|
};
|