OmniNX/Atmosphere
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tma: Add target initialization/power management logic

Browse Source
This commit is contained in:
Michael Scire
2018-12-05 05:31:45 -08:00
parent bf7dc84893
commit 37e5a8544b
5 changed files with 344 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

219
stratosphere/tma/source/tma_target.cpp Normal file
View File

@@ -0,0 +1,219 @@
/*
* Copyright (c) 2018 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <switch.h>
#include <stratosphere.hpp>
#include "tma_conn_connection.hpp"
#include "tma_conn_usb_connection.hpp"
#include "tma_service_manager.hpp"
#include "tma_power_manager.hpp"
#include "tma_target.hpp"
struct TmaTargetConfig {
char configuration_id1[0x80];
char serial_number[0x80];
};
static TmaConnection *g_active_connection = nullptr;
static TmaServiceManager *g_service_manager = nullptr;
static HosMutex g_connection_event_mutex;
static bool g_has_woken_up = false;
static bool g_signal_on_disconnect = false;
static TmaUsbConnection *g_usb_connection = nullptr;
static TmaTargetConfig g_target_config = {
"Unknown",
"SerialNumber",
};
static void RefreshTargetConfig() {
setsysInitialize();
/* TODO: setsysGetConfigurationId1(&g_target_config.configuration_id1); */
g_target_config.serial_number[0] = 0;
setsysGetSerialNumber(g_target_config.serial_number);
setsysExit();
}
static void InitializeServices() {
g_service_manager->Initialize();
}
static void FinalizeServices() {
g_service_manager->Finalize();
}
static void SetActiveConnection(TmaConnection *connection) {
if (g_active_connection != connection) {
if (g_active_connection != nullptr) {
FinalizeServices();
g_service_manager->SetConnection(nullptr);
g_active_connection->Disconnect();
g_active_connection = nullptr;
}
if (connection != nullptr) {
g_active_connection = connection;
InitializeServices();
g_service_manager->SetConnection(g_active_connection);
g_active_connection->SetServiceManager(g_service_manager);
}
}
}
static void OnConnectionEvent(void *arg, ConnectionEvent evt) {
std::scoped_lock<HosMutex> lk(g_connection_event_mutex);
switch (evt) {
case ConnectionEvent::Connected:
{
bool has_active_connection = false;
g_has_woken_up = false;
if (arg == g_usb_connection) {
SetActiveConnection(g_usb_connection);
has_active_connection = true;
}
if (has_active_connection) {
/* TODO: Signal connected */
}
}
break;
case ConnectionEvent::Disconnected:
if (g_signal_on_disconnect) {
/* TODO: Signal disconnected */
}
break;
default:
std::abort();
break;
}
}
static void Wake() {
if (g_service_manager->GetAsleep()) {
g_has_woken_up = true;
/* N checks what kind of connection to use here. For now, we only use USB. */
TmaUsbConnection::InitializeComms();
g_usb_connection = new TmaUsbConnection();
g_usb_connection->SetConnectionEventCallback(OnConnectionEvent, g_usb_connection);
g_usb_connection->Initialize();
SetActiveConnection(g_usb_connection);
g_service_manager->Wake(g_active_connection);
}
}
static void Sleep() {
if (!g_service_manager->GetAsleep()) {
if (g_active_connection->IsConnected()) {
/* TODO: Send a packet saying we're going to sleep. */
}
g_service_manager->Sleep();
g_service_manager->SetConnection(nullptr);
g_active_connection->Disconnect();
g_active_connection = nullptr;
g_service_manager->CancelTasks();
if (g_usb_connection != nullptr) {
g_usb_connection->Finalize();
delete g_usb_connection;
g_usb_connection = nullptr;
TmaUsbConnection::FinalizeComms();
}
}
}
static void OnPowerManagementEvent(PscPmState state, u32 flags) {
switch (state) {
case PscPmState_Awake:
{
Wake();
}
break;
case PscPmState_ReadyAwaken:
{
if (g_service_manager->GetAsleep()) {
Wake();
{
/* Try to restore a connection. */
bool connected = g_service_manager->GetConnected();
/* N uses a seven-second timeout, here. */
TimeoutHelper timeout_helper(7000000000ULL);
while (!connected && !timeout_helper.TimedOut()) {
connected = g_service_manager->GetConnected();
if (!connected) {
/* Sleep for 1ms. */
svcSleepThread(1000000ULL);
}
}
if (!connected) {
/* TODO: Signal disconnected */
}
}
}
}
break;
case PscPmState_ReadySleep:
{
Sleep();
}
break;
default:
/* Don't handle ReadySleepCritical/ReadyAwakenCritical/ReadyShutdown */
break;
}
}
void TmaTarget::Initialize() {
/* Get current thread priority. */
u32 cur_prio;
if (R_FAILED(svcGetThreadPriority(&cur_prio, CUR_THREAD_HANDLE))) {
std::abort();
}
g_active_connection = nullptr;
g_service_manager = new TmaServiceManager();
RefreshTargetConfig();
/* N checks what kind of connection to use here. For now, we only use USB. */
TmaUsbConnection::InitializeComms();
g_usb_connection = new TmaUsbConnection();
g_usb_connection->SetConnectionEventCallback(OnConnectionEvent, g_usb_connection);
g_usb_connection->Initialize();
SetActiveConnection(g_usb_connection);
/* TODO: Initialize connection events */
/* TODO: Initialize IPC services */
TmaPowerManager::Initialize(OnPowerManagementEvent);
}
void TmaTarget::Finalize() {
/* TODO: Is implementing this actually worthwhile? It will never be called in practice... */
}