forked from Bananymous/banan-os
439 lines
12 KiB
C++
439 lines
12 KiB
C++
#include <BAN/Bitcast.h>
|
|
|
|
#include <kernel/ACPI/AML/Namespace.h>
|
|
#include <kernel/ACPI/AML/Node.h>
|
|
#include <kernel/ACPI/Headers.h>
|
|
|
|
namespace Kernel::ACPI::AML
|
|
{
|
|
|
|
static Namespace s_root_namespace;
|
|
|
|
static constexpr BAN::StringView s_supported_osi_strings[] {
|
|
"Windows 2000"_sv,
|
|
"Windows 2001"_sv,
|
|
"Windows 2001 SP1"_sv,
|
|
"Windows 2001.1"_sv,
|
|
"Windows 2001 SP2"_sv,
|
|
"Windows 2001.1 SP1"_sv,
|
|
"Windows 2006.1"_sv,
|
|
"Windows 2006 SP1"_sv,
|
|
"Windows 2006 SP2"_sv,
|
|
"Windows 2009"_sv,
|
|
"Windows 2012"_sv,
|
|
"Windows 2013"_sv,
|
|
"Windows 2015"_sv,
|
|
"Windows 2016"_sv,
|
|
"Windows 2017"_sv,
|
|
"Windows 2017.2"_sv,
|
|
"Windows 2018"_sv,
|
|
"Windows 2018.2"_sv,
|
|
"Windows 2019"_sv,
|
|
"Extended Address Space Descriptor"_sv,
|
|
// just to pass osi test from uACPI :D
|
|
"AnotherTestString"_sv,
|
|
};
|
|
|
|
Namespace::~Namespace()
|
|
{
|
|
for (auto& [_, reference] : m_named_objects)
|
|
if (--reference->ref_count == 0)
|
|
delete reference;
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::initialize_root_namespace()
|
|
{
|
|
// https://uefi.org/htmlspecs/ACPI_Spec_6_4_html/05_ACPI_Software_Programming_Model/ACPI_Software_Programming_Model.html?highlight=predefined#predefined-root-namespaces
|
|
|
|
const auto add_predefined_root_namespace =
|
|
[](const char* name) -> BAN::ErrorOr<void>
|
|
{
|
|
Node predefined {};
|
|
predefined.type = Node::Type::PredefinedScope;
|
|
TRY(s_root_namespace.add_named_object({}, TRY(NameString::from_string(name)), BAN::move(predefined)));
|
|
return {};
|
|
};
|
|
|
|
TRY(add_predefined_root_namespace("\\"));
|
|
TRY(add_predefined_root_namespace("\\_GPE"));
|
|
TRY(add_predefined_root_namespace("\\_PR_"));
|
|
TRY(add_predefined_root_namespace("\\_SB_"));
|
|
TRY(add_predefined_root_namespace("\\_SI_"));
|
|
TRY(add_predefined_root_namespace("\\_TZ_"));
|
|
|
|
{
|
|
Node revision;
|
|
revision.type = Node::Type::Integer;
|
|
revision.as.integer.value = 2;
|
|
TRY(s_root_namespace.add_named_object({}, TRY(NameString::from_string("_REV")), BAN::move(revision)));
|
|
}
|
|
|
|
{
|
|
auto osi_string = TRY(NameString::from_string("\\_OSI"));
|
|
|
|
Node method {};
|
|
method.type = Node::Type::Method;
|
|
new (method.as.method.storage) Kernel::Mutex();
|
|
method.as.method.arg_count = 1;
|
|
method.as.method.override_func =
|
|
[](const BAN::Array<Reference*, 7>& args) -> BAN::ErrorOr<Node>
|
|
{
|
|
ASSERT(args[0]);
|
|
|
|
if (args[0]->node.type != Node::Type::String)
|
|
{
|
|
dwarnln("_OSI called with {}", args[0]->node);
|
|
return BAN::Error::from_errno(EINVAL);
|
|
}
|
|
|
|
const auto arg0 = BAN::StringView(
|
|
reinterpret_cast<const char*>(args[0]->node.as.str_buf->bytes),
|
|
args[0]->node.as.str_buf->size
|
|
);
|
|
|
|
Node result {};
|
|
result.type = Node::Type::Integer;
|
|
result.as.integer.value = 0;
|
|
|
|
for (auto supported : s_supported_osi_strings)
|
|
{
|
|
if (supported != arg0)
|
|
continue;
|
|
result.as.integer.value = 0xFFFFFFFFFFFFFFFF;
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
TRY(s_root_namespace.add_named_object({}, osi_string, BAN::move(method)));
|
|
}
|
|
|
|
{
|
|
auto gl_string = TRY(NameString::from_string("\\_GL_"));
|
|
|
|
Node mutex {};
|
|
mutex.type = Node::Type::Mutex;
|
|
mutex.as.mutex = new Mutex();
|
|
mutex.as.mutex->ref_count = 1;
|
|
mutex.as.mutex->sync_level = 0;
|
|
mutex.as.mutex->global_lock = true;
|
|
|
|
TRY(s_root_namespace.add_named_object({}, gl_string, BAN::move(mutex)));
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
Namespace& Namespace::root_namespace()
|
|
{
|
|
return s_root_namespace;
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::initalize_op_regions()
|
|
{
|
|
m_has_parsed_namespace = true;
|
|
|
|
for (const auto& [obj_path, obj_ref] : m_named_objects)
|
|
{
|
|
if (obj_ref->node.type != Node::Type::OpRegion)
|
|
continue;
|
|
// FIXME: if _REG adds stuff to namespace, iterators are invalidated
|
|
(void)opregion_call_reg(obj_path, obj_ref->node);
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::opregion_call_reg(const Scope& scope, const Node& opregion)
|
|
{
|
|
ASSERT(opregion.type == Node::Type::OpRegion);
|
|
|
|
const auto address_space = opregion.as.opregion.address_space;
|
|
if (address_space == GAS::AddressSpaceID::SystemIO || address_space == GAS::AddressSpaceID::SystemMemory)
|
|
return {};
|
|
const uint32_t address_space_u32 = static_cast<uint32_t>(address_space);
|
|
if (address_space_u32 >= 32)
|
|
return {};
|
|
const uint32_t mask = static_cast<uint32_t>(1) << address_space_u32;
|
|
|
|
auto parent = TRY(scope.copy());
|
|
parent.parts.pop_back();
|
|
|
|
auto it = m_called_reg_bitmaps.find(parent);
|
|
if (it != m_called_reg_bitmaps.end())
|
|
if (it->value & mask)
|
|
return {};
|
|
|
|
auto [reg_path, reg_obj] = TRY(find_named_object(parent, TRY(NameString::from_string("_REG"_sv)), true));
|
|
if (reg_obj != nullptr)
|
|
{
|
|
if (reg_obj->node.type != Node::Type::Method)
|
|
dwarnln("{} is not an method", reg_path);
|
|
else
|
|
{
|
|
if (reg_obj->node.as.method.arg_count != 2)
|
|
dwarnln("{} takes {} arguments", reg_obj->node.as.method.arg_count);
|
|
else
|
|
{
|
|
Reference arg0;
|
|
arg0.node.type = Node::Type::Integer;
|
|
arg0.node.as.integer.value = address_space_u32;
|
|
arg0.ref_count = 2; // evaluate should not delete
|
|
|
|
Reference arg1;
|
|
arg1.node.type = Node::Type::Integer;
|
|
arg1.node.as.integer.value = 1;
|
|
arg1.ref_count = 2; // evaluate should not delete
|
|
|
|
BAN::Array<Reference*, 7> args(nullptr);
|
|
args[0] = &arg0;
|
|
args[1] = &arg1;
|
|
|
|
if (auto ret = method_call(reg_path, reg_obj->node, BAN::move(args)); ret.is_error())
|
|
dwarnln("Failed to evaluate {}: {}", reg_path, ret.error());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (it != m_called_reg_bitmaps.end())
|
|
it->value |= mask;
|
|
else
|
|
TRY(m_called_reg_bitmaps.insert(BAN::move(parent), mask));
|
|
|
|
return {};
|
|
}
|
|
|
|
BAN::ErrorOr<Scope> Namespace::resolve_path(const Scope& scope, const NameString& name_string)
|
|
{
|
|
Scope resolved_path;
|
|
|
|
if (name_string.base == NameString::base_root)
|
|
{
|
|
TRY(resolved_path.parts.reserve(name_string.parts.size()));
|
|
for (uint32_t part : name_string.parts)
|
|
TRY(resolved_path.parts.push_back(part));
|
|
}
|
|
else
|
|
{
|
|
const uint32_t scope_segment_count =
|
|
(name_string.base < scope.parts.size())
|
|
? scope.parts.size() - name_string.base
|
|
: 0;
|
|
|
|
TRY(resolved_path.parts.reserve(scope_segment_count + name_string.parts.size()));
|
|
for (size_t i = 0; i < scope_segment_count; i++)
|
|
TRY(resolved_path.parts.push_back(scope.parts[i]));
|
|
for (uint32_t part : name_string.parts)
|
|
TRY(resolved_path.parts.push_back(part));
|
|
}
|
|
|
|
return resolved_path;
|
|
}
|
|
|
|
BAN::ErrorOr<Scope> Namespace::add_named_object(const Scope& scope, const NameString& name_string, Node&& node)
|
|
{
|
|
dprintln_if(AML_DUMP_FUNCTION_CALLS, "add_named_object('{}', '{}', {})", scope, name_string, node);
|
|
|
|
auto resolved_path = TRY(resolve_path(scope, name_string));
|
|
if (m_named_objects.contains(resolved_path))
|
|
return Scope();
|
|
|
|
auto* reference = new Reference();
|
|
if (reference == nullptr)
|
|
return BAN::Error::from_errno(ENOMEM);
|
|
reference->node = BAN::move(node);
|
|
reference->ref_count = 1;
|
|
|
|
TRY(m_named_objects.insert(TRY(resolved_path.copy()), reference));
|
|
|
|
if (m_has_parsed_namespace && reference->node.type == Node::Type::OpRegion)
|
|
(void)opregion_call_reg(resolved_path, reference->node);
|
|
|
|
return resolved_path;
|
|
}
|
|
|
|
BAN::ErrorOr<Scope> Namespace::add_named_object(const Scope& scope, const NameString& name_string, Reference* reference)
|
|
{
|
|
dprintln_if(AML_DUMP_FUNCTION_CALLS, "add_named_object('{}', '{}', {})", scope, name_string, reference->node);
|
|
|
|
auto resolved_path = TRY(resolve_path(scope, name_string));
|
|
if (m_named_objects.contains(resolved_path))
|
|
return Scope();
|
|
|
|
ASSERT(reference->ref_count >= 1);
|
|
reference->ref_count++;
|
|
|
|
TRY(m_named_objects.insert(TRY(resolved_path.copy()), reference));
|
|
return resolved_path;
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::remove_named_object(const Scope& absolute_path)
|
|
{
|
|
dprintln_if(AML_DUMP_FUNCTION_CALLS, "remove_named_object('{}')", absolute_path);
|
|
|
|
auto it = m_named_objects.find(absolute_path);
|
|
if (it == m_named_objects.end())
|
|
return BAN::Error::from_errno(ENOENT);
|
|
if (--it->value->ref_count == 0)
|
|
delete it->value;
|
|
m_named_objects.remove(it);
|
|
return {};
|
|
}
|
|
|
|
BAN::ErrorOr<Namespace::FindResult> Namespace::find_named_object(const Scope& scope, const NameString& name_string, bool force_absolute)
|
|
{
|
|
dprintln_if(AML_DUMP_FUNCTION_CALLS, "find_named_object('{}', '{}')", scope, name_string);
|
|
|
|
if (force_absolute || name_string.base != 0)
|
|
{
|
|
// Absolute path
|
|
|
|
auto resolved_path = TRY(resolve_path(scope, name_string));
|
|
auto it = m_named_objects.find(resolved_path);
|
|
if (it != m_named_objects.end()) {
|
|
return FindResult {
|
|
.path = BAN::move(resolved_path),
|
|
.node = it->value,
|
|
};
|
|
}
|
|
|
|
return FindResult {
|
|
.path = {},
|
|
.node = nullptr,
|
|
};
|
|
}
|
|
|
|
// Relative path
|
|
|
|
Scope path_guess;
|
|
TRY(path_guess.parts.reserve(scope.parts.size() + name_string.parts.size()));
|
|
for (const auto& part : scope.parts)
|
|
TRY(path_guess.parts.push_back(part));
|
|
for (const auto& part : name_string.parts)
|
|
TRY(path_guess.parts.push_back(part));
|
|
|
|
auto it = m_named_objects.find(path_guess);
|
|
if (it != m_named_objects.end()) {
|
|
return FindResult {
|
|
.path = BAN::move(path_guess),
|
|
.node = it->value,
|
|
};
|
|
}
|
|
|
|
for (size_t i = 0; i < scope.parts.size(); i++)
|
|
{
|
|
path_guess.parts.remove(scope.parts.size() - i - 1);
|
|
auto it = m_named_objects.find(path_guess);
|
|
if (it != m_named_objects.end()) {
|
|
return FindResult {
|
|
.path = BAN::move(path_guess),
|
|
.node = it->value,
|
|
};
|
|
}
|
|
}
|
|
|
|
return FindResult {
|
|
.path = {},
|
|
.node = nullptr,
|
|
};
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::for_each_child(const Scope& scope, const BAN::Function<BAN::Iteration(BAN::StringView, Reference*)>& callback)
|
|
{
|
|
for (const auto& [obj_path, obj_ref] : m_named_objects)
|
|
{
|
|
if (obj_path.parts.size() != scope.parts.size() + 1)
|
|
continue;
|
|
|
|
bool match = true;
|
|
for (size_t i = 0; i < scope.parts.size() && match; i++)
|
|
match = obj_path.parts[i] == scope.parts[i];
|
|
if (!match)
|
|
continue;
|
|
|
|
auto name = BAN::StringView(reinterpret_cast<const char*>(&obj_path.parts.back()), 4);
|
|
auto iteration = callback(name, obj_ref);
|
|
if (iteration == BAN::Iteration::Break)
|
|
break;
|
|
ASSERT(iteration == BAN::Iteration::Continue);
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::for_each_child(const Scope& scope, const BAN::Function<BAN::Iteration(const Scope&, Reference*)>& callback)
|
|
{
|
|
for (const auto& [obj_path, obj_ref] : m_named_objects)
|
|
{
|
|
if (obj_path.parts.size() != scope.parts.size() + 1)
|
|
continue;
|
|
|
|
bool match = true;
|
|
for (size_t i = 0; i < scope.parts.size() && match; i++)
|
|
match = obj_path.parts[i] == scope.parts[i];
|
|
if (!match)
|
|
continue;
|
|
|
|
auto iteration = callback(obj_path, obj_ref);
|
|
if (iteration == BAN::Iteration::Break)
|
|
break;
|
|
ASSERT(iteration == BAN::Iteration::Continue);
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
BAN::ErrorOr<Node> Namespace::evaluate(BAN::StringView path)
|
|
{
|
|
Scope root_scope;
|
|
auto name_string = TRY(NameString::from_string(path));
|
|
auto [object_path, object] = TRY(find_named_object(root_scope, name_string));
|
|
if (object == nullptr)
|
|
return BAN::Error::from_errno(ENOENT);
|
|
return evaluate_node(object_path, object->node);
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::parse(BAN::ConstByteSpan aml_data)
|
|
{
|
|
if (aml_data.size() < sizeof(SDTHeader))
|
|
return BAN::Error::from_errno(EINVAL);
|
|
|
|
const auto& sdt_header = aml_data.as<const SDTHeader>();
|
|
if (aml_data.size() < sdt_header.length)
|
|
return BAN::Error::from_errno(EINVAL);
|
|
|
|
aml_data = aml_data.slice(sizeof(SDTHeader));
|
|
|
|
ParseContext context;
|
|
context.aml_data = aml_data;
|
|
TRY(context.allocate_locals());
|
|
|
|
while (!context.aml_data.empty())
|
|
{
|
|
auto parse_result = parse_node_or_execution_flow(context);
|
|
if (parse_result.is_error())
|
|
{
|
|
dwarnln("Failed to parse root namespace: {}", parse_result.error());
|
|
return parse_result.release_error();
|
|
}
|
|
|
|
auto [execution_flow, node] = parse_result.release_value();
|
|
if (execution_flow == ExecutionFlow::Normal)
|
|
continue;
|
|
if (execution_flow == ExecutionFlow::Return)
|
|
break;
|
|
dwarnln("Root namespace got execution flow {}", static_cast<int>(execution_flow));
|
|
return BAN::Error::from_errno(EINVAL);
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
BAN::ErrorOr<void> Namespace::initialize_devices()
|
|
{
|
|
return {};
|
|
}
|
|
|
|
}
|