2014-07-06 20:15:40 -07:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
2014-12-16 21:38:14 -08:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-07-06 20:15:40 -07:00
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#include "common/common_types.h"
|
|
|
|
|
|
|
|
#include "core/mem_map.h"
|
|
|
|
|
|
|
|
#include "core/hle/hle.h"
|
|
|
|
#include "core/hle/kernel/address_arbiter.h"
|
|
|
|
#include "core/hle/kernel/thread.h"
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Kernel namespace
|
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
|
|
|
class AddressArbiter : public Object {
|
|
|
|
public:
|
2014-10-25 21:56:13 -07:00
|
|
|
std::string GetTypeName() const override { return "Arbiter"; }
|
|
|
|
std::string GetName() const override { return name; }
|
2014-07-06 20:15:40 -07:00
|
|
|
|
|
|
|
static Kernel::HandleType GetStaticHandleType() { return HandleType::AddressArbiter; }
|
2014-10-25 21:56:13 -07:00
|
|
|
Kernel::HandleType GetHandleType() const override { return HandleType::AddressArbiter; }
|
2014-07-06 20:15:40 -07:00
|
|
|
|
|
|
|
std::string name; ///< Name of address arbiter object (optional)
|
|
|
|
};
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/// Arbitrate an address
|
2014-10-22 20:20:01 -07:00
|
|
|
ResultCode ArbitrateAddress(Handle handle, ArbitrationType type, u32 address, s32 value) {
|
2014-07-06 20:15:40 -07:00
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
// Signal thread(s) waiting for arbitrate address...
|
|
|
|
case ArbitrationType::Signal:
|
|
|
|
// Negative value means resume all threads
|
|
|
|
if (value < 0) {
|
|
|
|
ArbitrateAllThreads(handle, address);
|
|
|
|
} else {
|
|
|
|
// Resume first N threads
|
|
|
|
for(int i = 0; i < value; i++)
|
|
|
|
ArbitrateHighestPriorityThread(handle, address);
|
|
|
|
}
|
2014-07-21 18:31:21 -07:00
|
|
|
break;
|
2014-07-06 20:15:40 -07:00
|
|
|
|
|
|
|
// Wait current thread (acquire the arbiter)...
|
|
|
|
case ArbitrationType::WaitIfLessThan:
|
|
|
|
if ((s32)Memory::Read32(address) <= value) {
|
2014-12-02 21:46:34 -08:00
|
|
|
Kernel::WaitCurrentThread(WAITTYPE_ARB, handle, address);
|
2014-07-06 20:15:40 -07:00
|
|
|
HLE::Reschedule(__func__);
|
|
|
|
}
|
2014-07-21 18:31:21 -07:00
|
|
|
break;
|
2014-07-06 20:15:40 -07:00
|
|
|
|
|
|
|
default:
|
2014-12-05 17:53:49 -08:00
|
|
|
LOG_ERROR(Kernel, "unknown type=%d", type);
|
2014-10-22 20:20:01 -07:00
|
|
|
return ResultCode(ErrorDescription::InvalidEnumValue, ErrorModule::Kernel, ErrorSummary::WrongArgument, ErrorLevel::Usage);
|
2014-07-06 20:15:40 -07:00
|
|
|
}
|
2014-10-22 20:20:01 -07:00
|
|
|
return RESULT_SUCCESS;
|
2014-07-06 20:15:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Create an address arbiter
|
|
|
|
AddressArbiter* CreateAddressArbiter(Handle& handle, const std::string& name) {
|
|
|
|
AddressArbiter* address_arbiter = new AddressArbiter;
|
|
|
|
handle = Kernel::g_object_pool.Create(address_arbiter);
|
|
|
|
address_arbiter->name = name;
|
|
|
|
return address_arbiter;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Create an address arbiter
|
|
|
|
Handle CreateAddressArbiter(const std::string& name) {
|
|
|
|
Handle handle;
|
|
|
|
CreateAddressArbiter(handle, name);
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Kernel
|