sneedmca/Lime3DS
1
0
Fork 0
mirror of https://github.com/Lime3DS/Lime3DS synced 2024-10-31 20:27:52 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #3361 from wwylele/ptm-new-framework

Browse source 
Service/PTM: convert to ServiceFramework
This commit is contained in:
James Rowe 2018-01-22 11:57:44 -07:00 committed by GitHub
commit 0e8c25fdfa
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 306 additions and 315 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

93
src/core/hle/service/ptm/ptm.cpp
View file

@ -13,7 +13,6 @@
#include "core/hle/service/ptm/ptm_sets.h" #include "core/hle/service/ptm/ptm_sets.h"
#include "core/hle/service/ptm/ptm_sysm.h" #include "core/hle/service/ptm/ptm_sysm.h"
#include "core/hle/service/ptm/ptm_u.h" #include "core/hle/service/ptm/ptm_u.h"
#include "core/hle/service/service.h"
#include "core/settings.h" #include "core/settings.h"
namespace Service { namespace Service {
@ -25,32 +24,26 @@ static const GameCoin default_game_coin = {0x4F00, 42, 0, 0, 0, 2014, 12, 29};
/// Id of the SharedExtData archive used by the PTM process /// Id of the SharedExtData archive used by the PTM process
static const std::vector<u8> ptm_shared_extdata_id = {0, 0, 0, 0, 0x0B, 0, 0, 0xF0, 0, 0, 0, 0}; static const std::vector<u8> ptm_shared_extdata_id = {0, 0, 0, 0, 0x0B, 0, 0, 0xF0, 0, 0, 0, 0};
static bool shell_open; void Module::Interface::GetAdapterState(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x5, 0, 0);
static bool battery_is_charging;
static bool pedometer_is_counting;
void GetAdapterState(Interface* self) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x5, 0, 0);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.Push(battery_is_charging); rb.Push(ptm->battery_is_charging);
LOG_WARNING(Service_PTM, "(STUBBED) called"); LOG_WARNING(Service_PTM, "(STUBBED) called");
} }
void GetShellState(Interface* self) { void Module::Interface::GetShellState(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x6, 0, 0); IPC::RequestParser rp(ctx, 0x6, 0, 0);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.Push(shell_open); rb.Push(ptm->shell_open);
} }
void GetBatteryLevel(Interface* self) { void Module::Interface::GetBatteryLevel(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x7, 0, 0); IPC::RequestParser rp(ctx, 0x7, 0, 0);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
@ -59,50 +52,52 @@ void GetBatteryLevel(Interface* self) {
LOG_WARNING(Service_PTM, "(STUBBED) called"); LOG_WARNING(Service_PTM, "(STUBBED) called");
} }
void GetBatteryChargeState(Interface* self) { void Module::Interface::GetBatteryChargeState(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x8, 0, 0); IPC::RequestParser rp(ctx, 0x8, 0, 0);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.Push(battery_is_charging); rb.Push(ptm->battery_is_charging);
LOG_WARNING(Service_PTM, "(STUBBED) called"); LOG_WARNING(Service_PTM, "(STUBBED) called");
} }
void GetPedometerState(Interface* self) { void Module::Interface::GetPedometerState(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x9, 0, 0); IPC::RequestParser rp(ctx, 0x9, 0, 0);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.Push(pedometer_is_counting); rb.Push(ptm->pedometer_is_counting);
LOG_WARNING(Service_PTM, "(STUBBED) called"); LOG_WARNING(Service_PTM, "(STUBBED) called");
} }
void GetStepHistory(Interface* self) { void Module::Interface::GetStepHistory(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0xB, 3, 2); IPC::RequestParser rp(ctx, 0xB, 3, 2);
u32 hours = rp.Pop<u32>(); u32 hours = rp.Pop<u32>();
u64 start_time = rp.Pop<u64>(); u64 start_time = rp.Pop<u64>();
size_t steps_buff_size; size_t steps_buff_size;
const VAddr steps_buff_addr = rp.PopMappedBuffer(&steps_buff_size); auto& buffer = rp.PopMappedBuffer();
ASSERT_MSG(sizeof(u16) * hours == steps_buff_size, "Buffer for steps count has incorrect size"); ASSERT_MSG(sizeof(u16) * hours == buffer.GetSize(),
"Buffer for steps count has incorrect size");
// Stub: set zero steps count for every hour // Stub: set zero steps count for every hour
for (u32 i = 0; i < hours; ++i) { for (u32 i = 0; i < hours; ++i) {
const u16 steps_per_hour = 0; const u16_le steps_per_hour = 0;
Memory::Write16(steps_buff_addr + i * sizeof(u16), steps_per_hour); buffer.Write(&steps_per_hour, i * sizeof(u16), sizeof(u16));
} }
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.PushMappedBuffer(buffer);
LOG_WARNING(Service_PTM, "(STUBBED) called, from time(raw): 0x%" PRIx64 ", for %u hours", LOG_WARNING(Service_PTM, "(STUBBED) called, from time(raw): 0x%" PRIx64 ", for %u hours",
start_time, hours); start_time, hours);
} }
void GetTotalStepCount(Interface* self) { void Module::Interface::GetTotalStepCount(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0xC, 0, 0); IPC::RequestParser rp(ctx, 0xC, 0, 0);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
@ -111,8 +106,8 @@ void GetTotalStepCount(Interface* self) {
LOG_WARNING(Service_PTM, "(STUBBED) called"); LOG_WARNING(Service_PTM, "(STUBBED) called");
} }
void GetSoftwareClosedFlag(Interface* self) { void Module::Interface::GetSoftwareClosedFlag(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(Kernel::GetCommandBuffer(), 0x80F, 0, 0); IPC::RequestParser rp(ctx, 0x80F, 0, 0);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
@ -135,23 +130,14 @@ void CheckNew3DS(IPC::RequestBuilder& rb) {
LOG_WARNING(Service_PTM, "(STUBBED) called isNew3DS = 0x%08x", static_cast<u32>(is_new_3ds)); LOG_WARNING(Service_PTM, "(STUBBED) called isNew3DS = 0x%08x", static_cast<u32>(is_new_3ds));
} }
void CheckNew3DS(Interface* self) { void Module::Interface::CheckNew3DS(Kernel::HLERequestContext& ctx) {
IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0x40A, 0, 0); // 0x040A0000 IPC::RequestParser rp(ctx, 0x40A, 0, 0);
CheckNew3DS(rb);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
Service::PTM::CheckNew3DS(rb);
} }
void Init() { Module::Module() {
AddService(new PTM_Gets);
AddService(new PTM_Play);
AddService(new PTM_S);
AddService(new PTM_Sets);
AddService(new PTM_Sysm);
AddService(new PTM_U);
shell_open = true;
battery_is_charging = true;
pedometer_is_counting = false;
// Open the SharedExtSaveData archive 0xF000000B and create the gamecoin.dat file if it doesn't // Open the SharedExtSaveData archive 0xF000000B and create the gamecoin.dat file if it doesn't
// exist // exist
FileSys::Path archive_path(ptm_shared_extdata_id); FileSys::Path archive_path(ptm_shared_extdata_id);
@ -183,7 +169,18 @@ void Init() {
} }
} }
void Shutdown() {} Module::Interface::Interface(std::shared_ptr<Module> ptm, const char* name, u32 max_session)
: ServiceFramework(name, max_session), ptm(std::move(ptm)) {}
void InstallInterfaces(SM::ServiceManager& service_manager) {
auto ptm = std::make_shared<Module>();
std::make_shared<PTM_Gets>(ptm)->InstallAsService(service_manager);
std::make_shared<PTM_Play>(ptm)->InstallAsService(service_manager);
std::make_shared<PTM_Sets>(ptm)->InstallAsService(service_manager);
std::make_shared<PTM_S>(ptm)->InstallAsService(service_manager);
std::make_shared<PTM_Sysm>(ptm)->InstallAsService(service_manager);
std::make_shared<PTM_U>(ptm)->InstallAsService(service_manager);
}
} // namespace PTM } // namespace PTM
} // namespace Service } // namespace Service

67
src/core/hle/service/ptm/ptm.h
View file

@ -4,13 +4,12 @@
#pragma once #pragma once
#include <memory>
#include "common/common_types.h" #include "common/common_types.h"
#include "core/hle/ipc_helpers.h" #include "core/hle/ipc_helpers.h"
#include "core/hle/service/service.h"
namespace Service { namespace Service {
class Interface;
namespace PTM { namespace PTM {
/// Charge levels used by PTM functions /// Charge levels used by PTM functions
@ -38,7 +37,18 @@ struct GameCoin {
u8 day; u8 day;
}; };
/** void CheckNew3DS(IPC::RequestBuilder& rb);
class Module final {
public:
Module();
class Interface : public ServiceFramework<Interface> {
public:
Interface(std::shared_ptr<Module> ptm, const char* name, u32 max_session);
protected:
/**
* It is unknown if GetAdapterState is the same as GetBatteryChargeState, * It is unknown if GetAdapterState is the same as GetBatteryChargeState,
* it is likely to just be a duplicate function of GetBatteryChargeState * it is likely to just be a duplicate function of GetBatteryChargeState
* that controls another part of the HW. * that controls another part of the HW.
@ -47,42 +57,42 @@ struct GameCoin {
* 1 : Result of function, 0 on success, otherwise error code * 1 : Result of function, 0 on success, otherwise error code
* 2 : Output of function, 0 = not charging, 1 = charging. * 2 : Output of function, 0 = not charging, 1 = charging.
*/ */
void GetAdapterState(Interface* self); void GetAdapterState(Kernel::HLERequestContext& ctx);
/** /**
* PTM::GetShellState service function. * PTM::GetShellState service function.
* Outputs: * Outputs:
* 1 : Result of function, 0 on success, otherwise error code * 1 : Result of function, 0 on success, otherwise error code
* 2 : Whether the 3DS's physical shell casing is open (1) or closed (0) * 2 : Whether the 3DS's physical shell casing is open (1) or closed (0)
*/ */
void GetShellState(Interface* self); void GetShellState(Kernel::HLERequestContext& ctx);
/** /**
* PTM::GetBatteryLevel service function * PTM::GetBatteryLevel service function
* Outputs: * Outputs:
* 1 : Result of function, 0 on success, otherwise error code * 1 : Result of function, 0 on success, otherwise error code
* 2 : Battery level, 5 = completely full battery, 4 = mostly full battery, * 2 : Battery level, 5 = completely full battery, 4 = mostly full battery,
* 3 = half full battery, 2 = low battery, 1 = critical battery. * 3 = half full battery, 2 = low battery, 1 = critical battery.
*/ */
void GetBatteryLevel(Interface* self); void GetBatteryLevel(Kernel::HLERequestContext& ctx);
/** /**
* PTM::GetBatteryChargeState service function * PTM::GetBatteryChargeState service function
* Outputs: * Outputs:
* 1 : Result of function, 0 on success, otherwise error code * 1 : Result of function, 0 on success, otherwise error code
* 2 : Output of function, 0 = not charging, 1 = charging. * 2 : Output of function, 0 = not charging, 1 = charging.
*/ */
void GetBatteryChargeState(Interface* self); void GetBatteryChargeState(Kernel::HLERequestContext& ctx);
/** /**
* PTM::GetPedometerState service function * PTM::GetPedometerState service function
* Outputs: * Outputs:
* 1 : Result of function, 0 on success, otherwise error code * 1 : Result of function, 0 on success, otherwise error code
* 2 : Output of function, 0 = not counting steps, 1 = counting steps. * 2 : Output of function, 0 = not counting steps, 1 = counting steps.
*/ */
void GetPedometerState(Interface* self); void GetPedometerState(Kernel::HLERequestContext& ctx);
/** /**
* PTM::GetStepHistory service function * PTM::GetStepHistory service function
* Inputs: * Inputs:
* 1 : Number of hours * 1 : Number of hours
@ -92,39 +102,44 @@ void GetPedometerState(Interface* self);
* Outputs: * Outputs:
* 1 : Result of function, 0 on success, otherwise error code * 1 : Result of function, 0 on success, otherwise error code
*/ */
void GetStepHistory(Interface* self); void GetStepHistory(Kernel::HLERequestContext& ctx);
/** /**
* PTM::GetTotalStepCount service function * PTM::GetTotalStepCount service function
* Outputs: * Outputs:
* 1 : Result of function, 0 on success, otherwise error code * 1 : Result of function, 0 on success, otherwise error code
* 2 : Output of function, * = total step count * 2 : Output of function, * = total step count
*/ */
void GetTotalStepCount(Interface* self); void GetTotalStepCount(Kernel::HLERequestContext& ctx);
/** /**
* PTM::GetSoftwareClosedFlag service function * PTM::GetSoftwareClosedFlag service function
* Outputs: * Outputs:
* 1: Result code, 0 on success, otherwise error code * 1: Result code, 0 on success, otherwise error code
* 2: Whether or not the "software closed" dialog was requested by the last FIRM * 2: Whether or not the "software closed" dialog was requested by the last FIRM
* and should be displayed. * and should be displayed.
*/ */
void GetSoftwareClosedFlag(Interface* self); void GetSoftwareClosedFlag(Kernel::HLERequestContext& ctx);
/** /**
* PTM::CheckNew3DS service function * PTM::CheckNew3DS service function
* Outputs: * Outputs:
* 1: Result code, 0 on success, otherwise error code * 1: Result code, 0 on success, otherwise error code
* 2: u8 output: 0 = Old3DS, 1 = New3DS. * 2: u8 output: 0 = Old3DS, 1 = New3DS.
*/ */
void CheckNew3DS(Interface* self); void CheckNew3DS(Kernel::HLERequestContext& ctx);
void CheckNew3DS(IPC::RequestBuilder& rb);
/// Initialize the PTM service private:
void Init(); std::shared_ptr<Module> ptm;
};
/// Shutdown the PTM service private:
void Shutdown(); bool shell_open = true;
bool battery_is_charging = true;
bool pedometer_is_counting = false;
};
void InstallInterfaces(SM::ServiceManager& service_manager);
} // namespace PTM } // namespace PTM
} // namespace Service } // namespace Service

23
src/core/hle/service/ptm/ptm_gets.cpp
View file

@ -2,35 +2,34 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "core/hle/service/ptm/ptm.h"
#include "core/hle/service/ptm/ptm_gets.h" #include "core/hle/service/ptm/ptm_gets.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
const Interface::FunctionInfo FunctionTable[] = { PTM_Gets::PTM_Gets(std::shared_ptr<Module> ptm)
: Module::Interface(std::move(ptm), "ptm:gets", 26) {
static const FunctionInfo functions[] = {
// ptm:u common commands // ptm:u common commands
{0x00010002, nullptr, "RegisterAlarmClient"}, {0x00010002, nullptr, "RegisterAlarmClient"},
{0x00020080, nullptr, "SetRtcAlarm"}, {0x00020080, nullptr, "SetRtcAlarm"},
{0x00030000, nullptr, "GetRtcAlarm"}, {0x00030000, nullptr, "GetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {0x00040000, nullptr, "CancelRtcAlarm"},
{0x00050000, GetAdapterState, "GetAdapterState"}, {0x00050000, &PTM_Gets::GetAdapterState, "GetAdapterState"},
{0x00060000, GetShellState, "GetShellState"}, {0x00060000, &PTM_Gets::GetShellState, "GetShellState"},
{0x00070000, GetBatteryLevel, "GetBatteryLevel"}, {0x00070000, &PTM_Gets::GetBatteryLevel, "GetBatteryLevel"},
{0x00080000, GetBatteryChargeState, "GetBatteryChargeState"}, {0x00080000, &PTM_Gets::GetBatteryChargeState, "GetBatteryChargeState"},
{0x00090000, nullptr, "GetPedometerState"}, {0x00090000, nullptr, "GetPedometerState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {0x000A0042, nullptr, "GetStepHistoryEntry"},
{0x000B00C2, GetStepHistory, "GetStepHistory"}, {0x000B00C2, &PTM_Gets::GetStepHistory, "GetStepHistory"},
{0x000C0000, GetTotalStepCount, "GetTotalStepCount"}, {0x000C0000, &PTM_Gets::GetTotalStepCount, "GetTotalStepCount"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {0x000D0040, nullptr, "SetPedometerRecordingMode"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {0x000E0000, nullptr, "GetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {0x000F0084, nullptr, "GetStepHistoryAll"},
// ptm:gets // ptm:gets
{0x04010000, nullptr, "GetSystemTime"}, {0x04010000, nullptr, "GetSystemTime"},
}; };
RegisterHandlers(functions);
PTM_Gets::PTM_Gets() {
Register(FunctionTable);
} }
} // namespace PTM } // namespace PTM

11
src/core/hle/service/ptm/ptm_gets.h
View file

@ -4,18 +4,15 @@
#pragma once #pragma once
#include "core/hle/service/service.h" #include <memory>
#include "core/hle/service/ptm/ptm.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
class PTM_Gets final : public Interface { class PTM_Gets final : public Module::Interface {
public: public:
PTM_Gets(); explicit PTM_Gets(std::shared_ptr<Module> ptm);
std::string GetPortName() const override {
return "ptm:gets";
}
}; };
} // namespace PTM } // namespace PTM

23
src/core/hle/service/ptm/ptm_play.cpp
View file

@ -2,26 +2,27 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "core/hle/service/ptm/ptm.h"
#include "core/hle/service/ptm/ptm_play.h" #include "core/hle/service/ptm/ptm_play.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
const Interface::FunctionInfo FunctionTable[] = { PTM_Play::PTM_Play(std::shared_ptr<Module> ptm)
: Module::Interface(std::move(ptm), "ptm:play", 26) {
static const FunctionInfo functions[] = {
// ptm:u common commands // ptm:u common commands
{0x00010002, nullptr, "RegisterAlarmClient"}, {0x00010002, nullptr, "RegisterAlarmClient"},
{0x00020080, nullptr, "SetRtcAlarm"}, {0x00020080, nullptr, "SetRtcAlarm"},
{0x00030000, nullptr, "GetRtcAlarm"}, {0x00030000, nullptr, "GetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {0x00040000, nullptr, "CancelRtcAlarm"},
{0x00050000, GetAdapterState, "GetAdapterState"}, {0x00050000, &PTM_Play::GetAdapterState, "GetAdapterState"},
{0x00060000, GetShellState, "GetShellState"}, {0x00060000, &PTM_Play::GetShellState, "GetShellState"},
{0x00070000, GetBatteryLevel, "GetBatteryLevel"}, {0x00070000, &PTM_Play::GetBatteryLevel, "GetBatteryLevel"},
{0x00080000, GetBatteryChargeState, "GetBatteryChargeState"}, {0x00080000, &PTM_Play::GetBatteryChargeState, "GetBatteryChargeState"},
{0x00090000, nullptr, "GetPedometerState"}, {0x00090000, nullptr, "GetPedometerState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {0x000A0042, nullptr, "GetStepHistoryEntry"},
{0x000B00C2, GetStepHistory, "GetStepHistory"}, {0x000B00C2, &PTM_Play::GetStepHistory, "GetStepHistory"},
{0x000C0000, GetTotalStepCount, "GetTotalStepCount"}, {0x000C0000, &PTM_Play::GetTotalStepCount, "GetTotalStepCount"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {0x000D0040, nullptr, "SetPedometerRecordingMode"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {0x000E0000, nullptr, "GetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {0x000F0084, nullptr, "GetStepHistoryAll"},
@ -30,10 +31,8 @@ const Interface::FunctionInfo FunctionTable[] = {
{0x08080000, nullptr, "GetPlayHistoryStart"}, {0x08080000, nullptr, "GetPlayHistoryStart"},
{0x08090000, nullptr, "GetPlayHistoryLength"}, {0x08090000, nullptr, "GetPlayHistoryLength"},
{0x080B0080, nullptr, "CalcPlayHistoryStart"}, {0x080B0080, nullptr, "CalcPlayHistoryStart"},
}; };
RegisterHandlers(functions);
PTM_Play::PTM_Play() {
Register(FunctionTable);
} }
} // namespace PTM } // namespace PTM

11
src/core/hle/service/ptm/ptm_play.h
View file

@ -4,18 +4,15 @@
#pragma once #pragma once
#include "core/hle/service/service.h" #include <memory>
#include "core/hle/service/ptm/ptm.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
class PTM_Play final : public Interface { class PTM_Play final : public Module::Interface {
public: public:
PTM_Play(); explicit PTM_Play(std::shared_ptr<Module> ptm);
std::string GetPortName() const override {
return "ptm:play";
}
}; };
} // namespace PTM } // namespace PTM

9
src/core/hle/service/ptm/ptm_sets.cpp
View file

@ -7,13 +7,12 @@
namespace Service { namespace Service {
namespace PTM { namespace PTM {
const Interface::FunctionInfo FunctionTable[] = { PTM_Sets::PTM_Sets(std::shared_ptr<Module> ptm) : Module::Interface(std::move(ptm), "ptm:sets", 1) {
static const FunctionInfo functions[] = {
// Note that this service does not have access to ptm:u's common commands // Note that this service does not have access to ptm:u's common commands
{0x00010080, nullptr, "SetSystemTime"}, {0x00010080, nullptr, "SetSystemTime"},
}; };
RegisterHandlers(functions);
PTM_Sets::PTM_Sets() {
Register(FunctionTable);
} }
} // namespace PTM } // namespace PTM

11
src/core/hle/service/ptm/ptm_sets.h
View file

@ -4,18 +4,15 @@
#pragma once #pragma once
#include "core/hle/service/service.h" #include <memory>
#include "core/hle/service/ptm/ptm.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
class PTM_Sets final : public Interface { class PTM_Sets final : public Module::Interface {
public: public:
PTM_Sets(); explicit PTM_Sets(std::shared_ptr<Module> ptm);
std::string GetPortName() const override {
return "ptm:sets";
}
}; };
} // namespace PTM } // namespace PTM

37
src/core/hle/service/ptm/ptm_sysm.cpp
View file

@ -2,30 +2,31 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "core/hle/service/ptm/ptm.h"
#include "core/hle/service/ptm/ptm_sysm.h" #include "core/hle/service/ptm/ptm_sysm.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
const Interface::FunctionInfo FunctionTable[] = { PTM_S_Common::PTM_S_Common(std::shared_ptr<Module> ptm, const char* name)
: Module::Interface(std::move(ptm), name, 26) {
static const FunctionInfo functions[] = {
// ptm:u common commands // ptm:u common commands
{0x00010002, nullptr, "RegisterAlarmClient"}, {0x00010002, nullptr, "RegisterAlarmClient"},
{0x00020080, nullptr, "SetRtcAlarm"}, {0x00020080, nullptr, "SetRtcAlarm"},
{0x00030000, nullptr, "GetRtcAlarm"}, {0x00030000, nullptr, "GetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {0x00040000, nullptr, "CancelRtcAlarm"},
{0x00050000, GetAdapterState, "GetAdapterState"}, {0x00050000, &PTM_S_Common::GetAdapterState, "GetAdapterState"},
{0x00060000, GetShellState, "GetShellState"}, {0x00060000, &PTM_S_Common::GetShellState, "GetShellState"},
{0x00070000, GetBatteryLevel, "GetBatteryLevel"}, {0x00070000, &PTM_S_Common::GetBatteryLevel, "GetBatteryLevel"},
{0x00080000, GetBatteryChargeState, "GetBatteryChargeState"}, {0x00080000, &PTM_S_Common::GetBatteryChargeState, "GetBatteryChargeState"},
{0x00090000, nullptr, "GetPedometerState"}, {0x00090000, nullptr, "GetPedometerState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {0x000A0042, nullptr, "GetStepHistoryEntry"},
{0x000B00C2, GetStepHistory, "GetStepHistory"}, {0x000B00C2, &PTM_S_Common::GetStepHistory, "GetStepHistory"},
{0x000C0000, GetTotalStepCount, "GetTotalStepCount"}, {0x000C0000, &PTM_S_Common::GetTotalStepCount, "GetTotalStepCount"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {0x000D0040, nullptr, "SetPedometerRecordingMode"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {0x000E0000, nullptr, "GetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {0x000F0084, nullptr, "GetStepHistoryAll"},
// ptm:sysm // ptm:sysm & ptm:s
{0x040100C0, nullptr, "SetRtcAlarmEx"}, {0x040100C0, nullptr, "SetRtcAlarmEx"},
{0x04020042, nullptr, "ReplySleepQuery"}, {0x04020042, nullptr, "ReplySleepQuery"},
{0x04030042, nullptr, "NotifySleepPreparationComplete"}, {0x04030042, nullptr, "NotifySleepPreparationComplete"},
@ -35,7 +36,7 @@ const Interface::FunctionInfo FunctionTable[] = {
{0x040700C0, nullptr, "ShutdownAsync"}, {0x040700C0, nullptr, "ShutdownAsync"},
{0x04080000, nullptr, "Awake"}, {0x04080000, nullptr, "Awake"},
{0x04090080, nullptr, "RebootAsync"}, {0x04090080, nullptr, "RebootAsync"},
{0x040A0000, CheckNew3DS, "CheckNew3DS"}, {0x040A0000, &PTM_S_Common::CheckNew3DS, "CheckNew3DS"},
{0x08010640, nullptr, "SetInfoLEDPattern"}, {0x08010640, nullptr, "SetInfoLEDPattern"},
{0x08020040, nullptr, "SetInfoLEDPatternHeader"}, {0x08020040, nullptr, "SetInfoLEDPatternHeader"},
{0x08030000, nullptr, "GetInfoLEDStatus"}, {0x08030000, nullptr, "GetInfoLEDStatus"},
@ -50,22 +51,20 @@ const Interface::FunctionInfo FunctionTable[] = {
{0x080C0080, nullptr, "SetUserTime"}, {0x080C0080, nullptr, "SetUserTime"},
{0x080D0000, nullptr, "InvalidateSystemTime"}, {0x080D0000, nullptr, "InvalidateSystemTime"},
{0x080E0140, nullptr, "NotifyPlayEvent"}, {0x080E0140, nullptr, "NotifyPlayEvent"},
{0x080F0000, GetSoftwareClosedFlag, "GetSoftwareClosedFlag"}, {0x080F0000, &PTM_S_Common::GetSoftwareClosedFlag, "GetSoftwareClosedFlag"},
{0x08100000, nullptr, "ClearSoftwareClosedFlag"}, {0x08100000, nullptr, "ClearSoftwareClosedFlag"},
{0x08110000, GetShellState, "GetShellState"}, {0x08110000, &PTM_S_Common::GetShellState, "GetShellState"},
{0x08120000, nullptr, "IsShutdownByBatteryEmpty"}, {0x08120000, nullptr, "IsShutdownByBatteryEmpty"},
{0x08130000, nullptr, "FormatSavedata"}, {0x08130000, nullptr, "FormatSavedata"},
{0x08140000, nullptr, "GetLegacyJumpProhibitedFlag"}, {0x08140000, nullptr, "GetLegacyJumpProhibitedFlag"},
{0x08180040, nullptr, "ConfigureNew3DSCPU"}, {0x08180040, nullptr, "ConfigureNew3DSCPU"},
}; };
RegisterHandlers(functions);
PTM_S::PTM_S() {
Register(FunctionTable);
} }
PTM_Sysm::PTM_Sysm() { PTM_S::PTM_S(std::shared_ptr<Module> ptm) : PTM_S_Common(std::move(ptm), "ptm:s") {}
Register(FunctionTable);
} PTM_Sysm::PTM_Sysm(std::shared_ptr<Module> ptm) : PTM_S_Common(std::move(ptm), "ptm:sysm") {}
} // namespace PTM } // namespace PTM
} // namespace Service } // namespace Service

22
src/core/hle/service/ptm/ptm_sysm.h
View file

@ -4,27 +4,25 @@
#pragma once #pragma once
#include "core/hle/service/service.h" #include <memory>
#include "core/hle/service/ptm/ptm.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
class PTM_S final : public Interface { class PTM_S_Common : public Module::Interface {
public: public:
PTM_S(); explicit PTM_S_Common(std::shared_ptr<Module> ptm, const char* name);
std::string GetPortName() const override {
return "ptm:s";
}
}; };
class PTM_Sysm final : public Interface { class PTM_S final : public PTM_S_Common {
public: public:
PTM_Sysm(); explicit PTM_S(std::shared_ptr<Module> ptm);
};
std::string GetPortName() const override { class PTM_Sysm final : public PTM_S_Common {
return "ptm:sysm"; public:
} explicit PTM_Sysm(std::shared_ptr<Module> ptm);
}; };
} // namespace PTM } // namespace PTM

24
src/core/hle/service/ptm/ptm_u.cpp
View file

@ -2,32 +2,30 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "core/hle/service/ptm/ptm.h"
#include "core/hle/service/ptm/ptm_u.h" #include "core/hle/service/ptm/ptm_u.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
const Interface::FunctionInfo FunctionTable[] = { PTM_U::PTM_U(std::shared_ptr<Module> ptm) : Module::Interface(std::move(ptm), "ptm:u", 26) {
static const FunctionInfo functions[] = {
{0x00010002, nullptr, "RegisterAlarmClient"}, {0x00010002, nullptr, "RegisterAlarmClient"},
{0x00020080, nullptr, "SetRtcAlarm"}, {0x00020080, nullptr, "SetRtcAlarm"},
{0x00030000, nullptr, "GetRtcAlarm"}, {0x00030000, nullptr, "GetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {0x00040000, nullptr, "CancelRtcAlarm"},
{0x00050000, GetAdapterState, "GetAdapterState"}, {0x00050000, &PTM_U::GetAdapterState, "GetAdapterState"},
{0x00060000, GetShellState, "GetShellState"}, {0x00060000, &PTM_U::GetShellState, "GetShellState"},
{0x00070000, GetBatteryLevel, "GetBatteryLevel"}, {0x00070000, &PTM_U::GetBatteryLevel, "GetBatteryLevel"},
{0x00080000, GetBatteryChargeState, "GetBatteryChargeState"}, {0x00080000, &PTM_U::GetBatteryChargeState, "GetBatteryChargeState"},
{0x00090000, GetPedometerState, "GetPedometerState"}, {0x00090000, &PTM_U::GetPedometerState, "GetPedometerState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {0x000A0042, nullptr, "GetStepHistoryEntry"},
{0x000B00C2, GetStepHistory, "GetStepHistory"}, {0x000B00C2, &PTM_U::GetStepHistory, "GetStepHistory"},
{0x000C0000, GetTotalStepCount, "GetTotalStepCount"}, {0x000C0000, &PTM_U::GetTotalStepCount, "GetTotalStepCount"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {0x000D0040, nullptr, "SetPedometerRecordingMode"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {0x000E0000, nullptr, "GetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {0x000F0084, nullptr, "GetStepHistoryAll"},
}; };
RegisterHandlers(functions);
PTM_U::PTM_U() {
Register(FunctionTable);
} }
} // namespace PTM } // namespace PTM

11
src/core/hle/service/ptm/ptm_u.h
View file

@ -4,18 +4,15 @@
#pragma once #pragma once
#include "core/hle/service/service.h" #include <memory>
#include "core/hle/service/ptm/ptm.h"
namespace Service { namespace Service {
namespace PTM { namespace PTM {
class PTM_U final : public Interface { class PTM_U final : public Module::Interface {
public: public:
PTM_U(); explicit PTM_U(std::shared_ptr<Module> ptm);
std::string GetPortName() const override {
return "ptm:u";
}
}; };
} // namespace PTM } // namespace PTM

3
src/core/hle/service/service.cpp
View file

@ -285,7 +285,7 @@ void Init() {
NFC::Init(); NFC::Init();
NIM::Init(); NIM::Init();
NWM::Init(); NWM::Init();
PTM::Init(); PTM::InstallInterfaces(*SM::g_service_manager);
QTM::Init(); QTM::Init();
AddService(new CSND::CSND_SND); AddService(new CSND::CSND_SND);
@ -302,7 +302,6 @@ void Init() {
/// Shutdown ServiceManager /// Shutdown ServiceManager
void Shutdown() { void Shutdown() {
PTM::Shutdown();
NFC::Shutdown(); NFC::Shutdown();
NIM::Shutdown(); NIM::Shutdown();
NEWS::Shutdown(); NEWS::Shutdown();