From e865fa6b62c5f41866a80f555bc8049fc811a0d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Resul=20=C3=96v=C3=BCr?= <92828257+ovurrsl@users.noreply.github.com> Date: Thu, 22 Oct 2026 06:55:00 +0300 Subject: [PATCH] fix: Steam Controller (Triton) output/feature reports are no longer overwritten unread (#1032) --- app/src/main/cpp/fakeinput_steam.cpp | 21 ++++++++++++++++--- .../launcher/input/FakeInputWriter.java | 18 ++++++++++------ 2 files changed, 30 insertions(+), 9 deletions(-) diff --git a/app/src/main/cpp/fakeinput_steam.cpp b/app/src/main/cpp/fakeinput_steam.cpp index ba4b14ec50..05d0138dde 100644 --- a/app/src/main/cpp/fakeinput_steam.cpp +++ b/app/src/main/cpp/fakeinput_steam.cpp @@ -1184,8 +1184,9 @@ struct TritonSharedData { uint32_t input_length; uint8_t input[64]; uint64_t output_seq; - uint32_t output_feature; - uint32_t output_length; + uint16_t output_feature; + uint16_t output_length; + uint32_t output_ack; uint8_t output[64]; uint64_t get_request; uint64_t get_reply; @@ -1202,6 +1203,8 @@ static_assert(offsetof(TritonSharedData, report_id) == 16, "Triton report ID off static_assert(offsetof(TritonSharedData, input) == 24, "Triton input offset"); static_assert(offsetof(TritonSharedData, output_seq) == 88, "Triton output sequence offset"); static_assert(offsetof(TritonSharedData, output_feature) == 96, "Triton output feature offset"); +static_assert(offsetof(TritonSharedData, output_length) == 98, "Triton output length offset"); +static_assert(offsetof(TritonSharedData, output_ack) == 100, "Triton output ack offset"); static_assert(offsetof(TritonSharedData, output) == 104, "Triton output offset"); static_assert(offsetof(TritonSharedData, get_request) == 168, "Triton feature request offset"); static_assert(offsetof(TritonSharedData, get_reply) == 176, "Triton feature reply offset"); @@ -1219,6 +1222,8 @@ static constexpr int TRITON_REPORT_ID_BYTES = 1; static constexpr int TRITON_STATE_BYTES = 45; static constexpr int TRITON_REPORT_INTERVAL_US = 4000; static constexpr int TRITON_FEATURE_TIMEOUT_MS = 500; +// The app clears output_length once it has taken a report; a writer waits this long for that before overwriting. +static constexpr int TRITON_OUTPUT_TIMEOUT_MS = 50; static constexpr const char *TRITON_NAME = "Steam Controller"; static constexpr const char *TRITON_SERIAL = "DROIDDECKSC01"; static const uint8_t kTritonReportDescriptor[] = { @@ -2574,11 +2579,21 @@ __attribute__((visibility("hidden"))) static void triton_queue_output(DeckHidraw if (!data || !size || size > 64 || triton.mapping_size < TRITON_SHARED_OFFSET + TRITON_SHARED_BLOCK_SIZE) return; auto *shared = reinterpret_cast(reinterpret_cast(triton.ring) + TRITON_SHARED_OFFSET); if (__atomic_load_n(&shared->magic, __ATOMIC_ACQUIRE) != TRITON_SHARED_MAGIC) return; + static std::mutex one_at_a_time; + std::lock_guard guard(one_at_a_time); + for (int waited = 0; + static_cast(__atomic_load_n(&shared->output_seq, __ATOMIC_ACQUIRE)) != + __atomic_load_n(&shared->output_ack, __ATOMIC_ACQUIRE) && + __atomic_load_n(&shared->connected, __ATOMIC_ACQUIRE) != 0 && waited < TRITON_OUTPUT_TIMEOUT_MS * 4; + waited++) { + struct timespec interval = {0, 250 * 1000L}; + nanosleep(&interval, nullptr); + } uint64_t seq = __atomic_load_n(&shared->output_seq, __ATOMIC_RELAXED); if (seq & 1) seq++; __atomic_store_n(&shared->output_seq, seq + 1, __ATOMIC_RELEASE); shared->output_feature = feature ? 1 : 0; - shared->output_length = static_cast(size); + shared->output_length = static_cast(size); memcpy(shared->output, data, size); if (size < sizeof(shared->output)) memset(shared->output + size, 0, sizeof(shared->output) - size); __atomic_thread_fence(__ATOMIC_RELEASE); diff --git a/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java b/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java index 308b6add85..05469e6340 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java +++ b/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java @@ -99,7 +99,8 @@ public class FakeInputWriter { private static final int TRITON_REPORT_OFFSET = TRITON_OFFSET + 24; private static final int TRITON_OUTPUT_SEQ_OFFSET = TRITON_OFFSET + 88; private static final int TRITON_OUTPUT_FEATURE_OFFSET = TRITON_OFFSET + 96; - private static final int TRITON_OUTPUT_LENGTH_OFFSET = TRITON_OFFSET + 100; + private static final int TRITON_OUTPUT_LENGTH_OFFSET = TRITON_OFFSET + 98; + private static final int TRITON_OUTPUT_ACK_OFFSET = TRITON_OFFSET + 100; private static final int TRITON_OUTPUT_OFFSET = TRITON_OFFSET + 104; private static final int TRITON_GET_REQUEST_OFFSET = TRITON_OFFSET + 168; private static final int TRITON_GET_REPLY_OFFSET = TRITON_OFFSET + 176; @@ -229,8 +230,9 @@ public class FakeInputWriter { data.putInt(TRITON_REPORT_ID_OFFSET, 0); data.putInt(TRITON_REPORT_LENGTH_OFFSET, 0); data.putLong(TRITON_OUTPUT_SEQ_OFFSET, 0L); - data.putInt(TRITON_OUTPUT_FEATURE_OFFSET, 0); - data.putInt(TRITON_OUTPUT_LENGTH_OFFSET, 0); + data.putShort(TRITON_OUTPUT_FEATURE_OFFSET, (short) 0); + data.putShort(TRITON_OUTPUT_LENGTH_OFFSET, (short) 0); + data.putInt(TRITON_OUTPUT_ACK_OFFSET, 0); data.putLong(TRITON_GET_REQUEST_OFFSET, 0L); data.putLong(TRITON_GET_REPLY_OFFSET, 0L); } @@ -587,14 +589,18 @@ public class FakeInputWriter { nativeStoreFence(); long seq = ring.getLong(TRITON_OUTPUT_SEQ_OFFSET); if ((seq & 1) != 0 || seq <= lastSequence) return null; - int length = ring.getInt(TRITON_OUTPUT_LENGTH_OFFSET); + int length = ring.getShort(TRITON_OUTPUT_LENGTH_OFFSET) & 0xffff; if (length <= 0 || length > TRITON_REPORT_MAX) return null; byte[] output = new byte[9 + length]; ByteBuffer.wrap(output).order(ByteOrder.LITTLE_ENDIAN).putLong(seq); - output[8] = (byte) (ring.getInt(TRITON_OUTPUT_FEATURE_OFFSET) != 0 ? 1 : 0); + output[8] = (byte) (ring.getShort(TRITON_OUTPUT_FEATURE_OFFSET) != 0 ? 1 : 0); for (int i = 0; i < length; i++) output[9 + i] = ring.get(TRITON_OUTPUT_OFFSET + i); nativeStoreFence(); - return seq == ring.getLong(TRITON_OUTPUT_SEQ_OFFSET) ? output : null; + if (seq != ring.getLong(TRITON_OUTPUT_SEQ_OFFSET)) return null; + // Acknowledge the exact report sequence taken so a concurrent timeout overwrite cannot lose its length. + ring.putInt(TRITON_OUTPUT_ACK_OFFSET, (int) seq); + nativeStoreFence(); + return output; } }