nold/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere synced 2025-01-03 11:11:14 +00:00
Code Issues Projects Releases Packages Wiki Activity

htc: free ourselves from the tyranny of numerical enums

Browse source
This commit is contained in:
Michael Scire 2021-02-08 06:48:30 -08:00 committed by SciresM
parent 2341f18edd
commit e40eece74e
6 changed files with 131 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
libraries/libstratosphere/include/stratosphere/htclow/htclow_channel_types.hpp
View file

@ -31,19 +31,22 @@ namespace ams::htclow {
ChannelState_Connectable = 0, ChannelState_Connectable = 0,
ChannelState_Unconnectable = 1, ChannelState_Unconnectable = 1,
ChannelState_Connected = 2, ChannelState_Connected = 2,
ChannelState_Shutdown = 3, ChannelState_Disconnected = 3,
}; };
constexpr bool IsStateTransitionAllowed(ChannelState from, ChannelState to) { constexpr bool IsStateTransitionAllowed(ChannelState from, ChannelState to) {
switch (from) { switch (from) {
case ChannelState_Connectable: case ChannelState_Connectable:
return to == ChannelState_Unconnectable || to == ChannelState_Connected || to == ChannelState_Shutdown; return to == ChannelState_Unconnectable ||
to == ChannelState_Connected ||
to == ChannelState_Disconnected;
case ChannelState_Unconnectable: case ChannelState_Unconnectable:
return to == ChannelState_Connectable || to == ChannelState_Shutdown; return to == ChannelState_Connectable ||
to == ChannelState_Disconnected;
case ChannelState_Connected: case ChannelState_Connected:
return to == ChannelState_Shutdown; return to == ChannelState_Disconnected;
case ChannelState_Shutdown: case ChannelState_Disconnected:
return to == ChannelState_Shutdown; return to == ChannelState_Disconnected;
AMS_UNREACHABLE_DEFAULT_CASE(); AMS_UNREACHABLE_DEFAULT_CASE();
} }
} }

12
libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_service.cpp
View file

@ -87,10 +87,10 @@ namespace ams::htclow::ctrl {
/* Lock ourselves. */ /* Lock ourselves. */
std::scoped_lock lk(m_mutex); std::scoped_lock lk(m_mutex);
if (m_state_machine->GetHtcctrlState() == HtcctrlState_7) { if (m_state_machine->GetHtcctrlState() == HtcctrlState_Sleep) {
R_TRY(this->SetState(HtcctrlState_8)); R_TRY(this->SetState(HtcctrlState_ExitSleep));
} else { } else {
R_TRY(this->SetState(HtcctrlState_0)); R_TRY(this->SetState(HtcctrlState_DriverConnected));
} }
return ResultSuccess(); return ResultSuccess();
@ -100,10 +100,10 @@ namespace ams::htclow::ctrl {
/* Lock ourselves. */ /* Lock ourselves. */
std::scoped_lock lk(m_mutex); std::scoped_lock lk(m_mutex);
if (m_state_machine->GetHtcctrlState() == HtcctrlState_6) { if (m_state_machine->GetHtcctrlState() == HtcctrlState_EnterSleep) {
R_TRY(this->SetState(HtcctrlState_7)); R_TRY(this->SetState(HtcctrlState_Sleep));
} else { } else {
R_TRY(this->SetState(HtcctrlState_11)); R_TRY(this->SetState(HtcctrlState_DriverDisconnected));
} }
return ResultSuccess(); return ResultSuccess();

158
libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_state.hpp
View file

@ -19,57 +19,89 @@
namespace ams::htclow::ctrl { namespace ams::htclow::ctrl {
enum HtcctrlState : u32 { enum HtcctrlState : u32 {
HtcctrlState_0 = 0, HtcctrlState_DriverConnected = 0,
HtcctrlState_1 = 1, HtcctrlState_SentConnectFromHost = 1,
HtcctrlState_2 = 2, HtcctrlState_Connected = 2,
HtcctrlState_3 = 3, HtcctrlState_SentReadyFromHost = 3,
HtcctrlState_4 = 4, HtcctrlState_Ready = 4,
HtcctrlState_5 = 5, HtcctrlState_SentSuspendFromTarget = 5,
HtcctrlState_6 = 6, HtcctrlState_EnterSleep = 6,
HtcctrlState_7 = 7, HtcctrlState_Sleep = 7,
HtcctrlState_8 = 8, HtcctrlState_ExitSleep = 8,
HtcctrlState_9 = 9, HtcctrlState_SentResumeFromTarget = 9,
HtcctrlState_10 = 10, HtcctrlState_Disconnected = 10,
HtcctrlState_11 = 11, HtcctrlState_DriverDisconnected = 11,
HtcctrlState_12 = 12, HtcctrlState_Error = 12,
}; };
constexpr bool IsStateTransitionAllowed(HtcctrlState from, HtcctrlState to) { constexpr bool IsStateTransitionAllowed(HtcctrlState from, HtcctrlState to) {
switch (from) { switch (from) {
case HtcctrlState_0: case HtcctrlState_DriverConnected:
return to == HtcctrlState_1 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; return to == HtcctrlState_SentConnectFromHost ||
case HtcctrlState_1: to == HtcctrlState_Disconnected ||
return to == HtcctrlState_2 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; to == HtcctrlState_DriverDisconnected ||
case HtcctrlState_2: to == HtcctrlState_Error;
return to == HtcctrlState_3 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; case HtcctrlState_SentConnectFromHost:
case HtcctrlState_3: return to == HtcctrlState_Connected ||
return to == HtcctrlState_4 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; to == HtcctrlState_Disconnected ||
case HtcctrlState_4: to == HtcctrlState_DriverDisconnected ||
return to == HtcctrlState_5 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; to == HtcctrlState_Error;
case HtcctrlState_5: case HtcctrlState_Connected:
return to == HtcctrlState_6 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; return to == HtcctrlState_SentReadyFromHost ||
case HtcctrlState_6: to == HtcctrlState_Disconnected ||
return to == HtcctrlState_7 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; to == HtcctrlState_DriverDisconnected ||
case HtcctrlState_7: to == HtcctrlState_Error;
return to == HtcctrlState_8; case HtcctrlState_SentReadyFromHost:
case HtcctrlState_8: return to == HtcctrlState_Ready ||
return to == HtcctrlState_9 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; to == HtcctrlState_Disconnected ||
case HtcctrlState_9: to == HtcctrlState_DriverDisconnected ||
return to == HtcctrlState_4 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; to == HtcctrlState_Error;
case HtcctrlState_10: case HtcctrlState_Ready:
return to == HtcctrlState_1 || to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; return to == HtcctrlState_SentSuspendFromTarget ||
case HtcctrlState_11: to == HtcctrlState_Disconnected ||
return to == HtcctrlState_0; to == HtcctrlState_DriverDisconnected ||
case HtcctrlState_12: to == HtcctrlState_Error;
return to == HtcctrlState_10 || to == HtcctrlState_11 || to == HtcctrlState_12; case HtcctrlState_SentSuspendFromTarget:
return to == HtcctrlState_EnterSleep ||
to == HtcctrlState_Disconnected ||
to == HtcctrlState_DriverDisconnected ||
to == HtcctrlState_Error;
case HtcctrlState_EnterSleep:
return to == HtcctrlState_Sleep ||
to == HtcctrlState_Disconnected ||
to == HtcctrlState_DriverDisconnected ||
to == HtcctrlState_Error;
case HtcctrlState_Sleep:
return to == HtcctrlState_ExitSleep;
case HtcctrlState_ExitSleep:
return to == HtcctrlState_SentResumeFromTarget ||
to == HtcctrlState_Disconnected ||
to == HtcctrlState_DriverDisconnected ||
to == HtcctrlState_Error;
case HtcctrlState_SentResumeFromTarget:
return to == HtcctrlState_Ready ||
to == HtcctrlState_Disconnected ||
to == HtcctrlState_DriverDisconnected ||
to == HtcctrlState_Error;
case HtcctrlState_Disconnected:
return to == HtcctrlState_SentConnectFromHost ||
to == HtcctrlState_Disconnected ||
to == HtcctrlState_DriverDisconnected ||
to == HtcctrlState_Error;
case HtcctrlState_DriverDisconnected:
return to == HtcctrlState_DriverConnected;
case HtcctrlState_Error:
return to == HtcctrlState_Disconnected ||
to == HtcctrlState_DriverDisconnected ||
to == HtcctrlState_Error;
AMS_UNREACHABLE_DEFAULT_CASE(); AMS_UNREACHABLE_DEFAULT_CASE();
} }
} }
constexpr bool IsDisconnected(HtcctrlState state) { constexpr bool IsDisconnected(HtcctrlState state) {
switch (state) { switch (state) {
case HtcctrlState_10: case HtcctrlState_Disconnected:
case HtcctrlState_11: case HtcctrlState_DriverDisconnected:
return true; return true;
default: default:
return false; return false;
@ -78,9 +110,9 @@ namespace ams::htclow::ctrl {
constexpr bool IsConnecting(HtcctrlState state) { constexpr bool IsConnecting(HtcctrlState state) {
switch (state) { switch (state) {
case HtcctrlState_0: case HtcctrlState_DriverConnected:
case HtcctrlState_1: case HtcctrlState_SentConnectFromHost:
case HtcctrlState_10: case HtcctrlState_Disconnected:
return true; return true;
default: default:
return false; return false;
@ -89,14 +121,14 @@ namespace ams::htclow::ctrl {
constexpr bool IsConnected(HtcctrlState state) { constexpr bool IsConnected(HtcctrlState state) {
switch (state) { switch (state) {
case HtcctrlState_2: case HtcctrlState_Connected:
case HtcctrlState_3: case HtcctrlState_SentReadyFromHost:
case HtcctrlState_4: case HtcctrlState_Ready:
case HtcctrlState_5: case HtcctrlState_SentSuspendFromTarget:
case HtcctrlState_6: case HtcctrlState_EnterSleep:
case HtcctrlState_7: case HtcctrlState_Sleep:
case HtcctrlState_8: case HtcctrlState_ExitSleep:
case HtcctrlState_9: case HtcctrlState_SentResumeFromTarget:
return true; return true;
default: default:
return false; return false;
@ -105,12 +137,12 @@ namespace ams::htclow::ctrl {
constexpr bool IsReadied(HtcctrlState state) { constexpr bool IsReadied(HtcctrlState state) {
switch (state) { switch (state) {
case HtcctrlState_4: case HtcctrlState_Ready:
case HtcctrlState_5: case HtcctrlState_SentSuspendFromTarget:
case HtcctrlState_6: case HtcctrlState_EnterSleep:
case HtcctrlState_7: case HtcctrlState_Sleep:
case HtcctrlState_8: case HtcctrlState_ExitSleep:
case HtcctrlState_9: case HtcctrlState_SentResumeFromTarget:
return true; return true;
default: default:
return false; return false;
@ -119,11 +151,11 @@ namespace ams::htclow::ctrl {
constexpr bool IsSleeping(HtcctrlState state) { constexpr bool IsSleeping(HtcctrlState state) {
switch (state) { switch (state) {
case HtcctrlState_5: case HtcctrlState_SentSuspendFromTarget:
case HtcctrlState_6: case HtcctrlState_EnterSleep:
case HtcctrlState_7: case HtcctrlState_Sleep:
case HtcctrlState_8: case HtcctrlState_ExitSleep:
case HtcctrlState_9: case HtcctrlState_SentResumeFromTarget:
return true; return true;
default: default:
return false; return false;

13
libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_state_machine.cpp
View file

@ -42,7 +42,7 @@ namespace ams::htclow::ctrl {
} }
HtcctrlStateMachine::HtcctrlStateMachine() : m_map(), m_state(HtcctrlState_11), m_prev_state(HtcctrlState_11), m_mutex() { HtcctrlStateMachine::HtcctrlStateMachine() : m_map(), m_state(HtcctrlState_DriverDisconnected), m_prev_state(HtcctrlState_DriverDisconnected), m_mutex() {
/* Lock ourselves. */ /* Lock ourselves. */
std::scoped_lock lk(m_mutex); std::scoped_lock lk(m_mutex);
@ -153,28 +153,25 @@ namespace ams::htclow::ctrl {
/* Lock ourselves. */ /* Lock ourselves. */
std::scoped_lock lk(m_mutex); std::scoped_lock lk(m_mutex);
/* TODO: What do these values mean? */
auto it = m_map.find(channel); auto it = m_map.find(channel);
return it != m_map.end() && it->second._04 == 2 && it->second._00 == 2; return it != m_map.end() && it->second.connect == ServiceChannelConnect_ConnectingChecked && it->second.support == ServiceChannelSupport_Unsupported;
} }
bool HtcctrlStateMachine::IsConnectable(const impl::ChannelInternalType &channel) { bool HtcctrlStateMachine::IsConnectable(const impl::ChannelInternalType &channel) {
/* Lock ourselves. */ /* Lock ourselves. */
std::scoped_lock lk(m_mutex); std::scoped_lock lk(m_mutex);
/* TODO: What do these values mean? */
auto it = m_map.find(channel); auto it = m_map.find(channel);
return ctrl::IsConnected(m_state) && (!(it != m_map.end()) || it->second._04 != 2); return ctrl::IsConnected(m_state) && (it == m_map.end() || it->second.connect != ServiceChannelConnect_ConnectingChecked);
} }
void HtcctrlStateMachine::SetNotConnecting(const impl::ChannelInternalType &channel) { void HtcctrlStateMachine::SetNotConnecting(const impl::ChannelInternalType &channel) {
/* Lock ourselves. */ /* Lock ourselves. */
std::scoped_lock lk(m_mutex); std::scoped_lock lk(m_mutex);
/* TODO: What do these values mean? */
auto it = m_map.find(channel); auto it = m_map.find(channel);
if (it != m_map.end() && it->second._04 != 2) { if (it != m_map.end() && it->second.connect != ServiceChannelConnect_ConnectingChecked) {
it->second._04 = 0; it->second.connect = ServiceChannelConnect_NotConnecting;
} }
} }

16
libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_state_machine.hpp
View file

@ -21,9 +21,21 @@ namespace ams::htclow::ctrl {
class HtcctrlStateMachine { class HtcctrlStateMachine {
private: private:
enum ServiceChannelSupport {
ServiceChannelSupport_Unknown = 0,
ServiceChannelSupport_Suppported = 1,
ServiceChannelSupport_Unsupported = 2,
};
enum ServiceChannelConnect {
ServiceChannelConnect_NotConnecting = 0,
ServiceChannelConnect_Connecting = 1,
ServiceChannelConnect_ConnectingChecked = 2,
};
struct ServiceChannelState { struct ServiceChannelState {
u32 _00; ServiceChannelSupport support;
u32 _04; ServiceChannelConnect connect;
}; };
static constexpr int MaxChannelCount = 10; static constexpr int MaxChannelCount = 10;

4
libraries/libstratosphere/source/htclow/mux/htclow_mux_channel_impl.cpp
View file

@ -59,7 +59,7 @@ namespace ams::htclow::mux {
m_send_buffer.Clear(); m_send_buffer.Clear();
/* Set our state to shutdown. */ /* Set our state to shutdown. */
this->SetState(ChannelState_Shutdown); this->SetState(ChannelState_Disconnected);
} }
void ChannelImpl::SetState(ChannelState state) { void ChannelImpl::SetState(ChannelState state) {
@ -78,7 +78,7 @@ namespace ams::htclow::mux {
} }
/* If relevant, notify disconnect. */ /* If relevant, notify disconnect. */
if (m_state == ChannelState_Shutdown) { if (m_state == ChannelState_Disconnected) {
m_task_manager->NotifyDisconnect(m_channel); m_task_manager->NotifyDisconnect(m_channel);
} }
} }