Make "detected_host_os()" available on the SLAVE side of the split keyboard

quantum/os_detection.c

@@ -36,48 +36,48 @@ struct setups_data_t {
     uint8_t      cnt_04;
     uint8_t      cnt_ff;
     uint16_t     last_wlength;
-    os_variant_t detected_os;
 };
 
 struct setups_data_t setups_data = {
     .count       = 0,
     .cnt_02      = 0,
     .cnt_04      = 0,
     .cnt_ff      = 0,
-    .detected_os = OS_UNSURE,
 };
 
+os_variant_t detected_os = OS_UNSURE;
+
 // Some collected sequences of wLength can be found in tests.
 void make_guess(void) {
     if (setups_data.count < 3) {
         return;
     }
     if (setups_data.cnt_ff >= 2 && setups_data.cnt_04 >= 1) {
-        setups_data.detected_os = OS_WINDOWS;
+        detected_os = OS_WINDOWS;
         return;
     }
     if (setups_data.count == setups_data.cnt_ff) {
         // Linux has 3 packets with 0xFF.
-        setups_data.detected_os = OS_LINUX;
+        detected_os = OS_LINUX;
         return;
     }
     if (setups_data.count == 5 && setups_data.last_wlength == 0xFF && setups_data.cnt_ff == 1 && setups_data.cnt_02 == 2) {
-        setups_data.detected_os = OS_MACOS;
+        detected_os = OS_MACOS;
         return;
     }
     if (setups_data.count == 4 && setups_data.cnt_ff == 0 && setups_data.cnt_02 == 2) {
         // iOS and iPadOS don't have the last 0xFF packet.
-        setups_data.detected_os = OS_IOS;
+        detected_os = OS_IOS;
         return;
     }
     if (setups_data.cnt_ff == 0 && setups_data.cnt_02 == 3 && setups_data.cnt_04 == 1) {
         // This is actually PS5.
-        setups_data.detected_os = OS_LINUX;
+        detected_os = OS_LINUX;
         return;
     }
     if (setups_data.cnt_ff >= 1 && setups_data.cnt_02 == 0 && setups_data.cnt_04 == 0) {
         // This is actually Quest 2 or Nintendo Switch.
-        setups_data.detected_os = OS_LINUX;
+        detected_os = OS_LINUX;
         return;
     }
 }
@@ -99,11 +99,12 @@ void process_wlength(const uint16_t w_length) {
 }
 
 os_variant_t detected_host_os(void) {
-    return setups_data.detected_os;
+    return detected_os;
 }
 
 void erase_wlength_data(void) {
     memset(&setups_data, 0, sizeof(setups_data));
+    detected_os = OS_UNSURE;
 }
 #endif // OS_DETECTION_ENABLE
 

quantum/os_detection.h

@@ -27,6 +27,11 @@ typedef enum {
     OS_IOS,
 } os_variant_t;
 
+/* splits where the slave side needs to process for rgb/oled functionality
+ * define "SPLIT_DETECTED_OS_ENABLE" to enable  
+ */
+extern os_variant_t detected_os;
+
 void         process_wlength(const uint16_t w_length);
 os_variant_t detected_host_os(void);
 void         erase_wlength_data(void);

quantum/split_common/transaction_id_define.h

@@ -109,6 +109,10 @@ enum serial_transaction_id {
     SPLIT_TRANSACTION_IDS_USER,
 #endif // SPLIT_TRANSACTION_IDS_USER
 
+#if defined(SPLIT_DETECTED_OS_ENABLE)
+    PUT_DETECTED_OS,
+#endif // define(SPLIT_DETECTED_OS_ENABLE)
+
     NUM_TOTAL_TRANSACTIONS
 };
 

quantum/split_common/transactions.c

@@ -790,6 +790,33 @@ static void haptic_handlers_slave(matrix_row_t master_matrix[], matrix_row_t sla
 
 #endif // defined(HAPTIC_ENABLE) && defined(SPLIT_HAPTIC_ENABLE)
 
+////////////////////////////////////////////////////
+// Detected OS
+
+#if defined(SPLIT_DETECTED_OS_ENABLE)
+
+static bool detected_os_handlers_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) {
+    static uint32_t last_detected_os_update = 0;
+    bool okay = send_if_condition(PUT_DETECTED_OS, &last_detected_os_update, (detected_os != split_shmem->detected_os), &detected_os, sizeof(os_variant_t));
+    return okay;
+}
+
+static void detected_os_handlers_slave(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) {
+    memcpy(&detected_os, &split_shmem->detected_os, sizeof(os_variant_t));
+}
+
+#    define TRANSACTIONS_DETECTED_OS_MASTER() TRANSACTION_HANDLER_MASTER(detected_os)
+#    define TRANSACTIONS_DETECTED_OS_SLAVE() TRANSACTION_HANDLER_SLAVE_AUTOLOCK(detected_os)
+#    define TRANSACTIONS_DETECTED_OS_REGISTRATIONS [PUT_DETECTED_OS] = trans_initiator2target_initializer(detected_os),
+
+#else // define(SPLIT_DETECTED_OS_ENABLE)
+
+#    define TRANSACTIONS_DETECTED_OS_MASTER()
+#    define TRANSACTIONS_DETECTED_OS_SLAVE()
+#    define TRANSACTIONS_DETECTED_OS_REGISTRATIONS
+
+#endif // define(SPLIT_DETECTED_OS_ENABLE)
+
 ////////////////////////////////////////////////////
 
 split_transaction_desc_t split_transaction_table[NUM_TOTAL_TRANSACTIONS] = {
@@ -818,6 +845,7 @@ split_transaction_desc_t split_transaction_table[NUM_TOTAL_TRANSACTIONS] = {
     TRANSACTIONS_POINTING_REGISTRATIONS
     TRANSACTIONS_WATCHDOG_REGISTRATIONS
     TRANSACTIONS_HAPTIC_REGISTRATIONS
+    TRANSACTIONS_DETECTED_OS_REGISTRATIONS
 // clang-format on
 
 #if defined(SPLIT_TRANSACTION_IDS_KB) || defined(SPLIT_TRANSACTION_IDS_USER)
@@ -846,6 +874,7 @@ bool transactions_master(matrix_row_t master_matrix[], matrix_row_t slave_matrix
     TRANSACTIONS_POINTING_MASTER();
     TRANSACTIONS_WATCHDOG_MASTER();
     TRANSACTIONS_HAPTIC_MASTER();
+    TRANSACTIONS_DETECTED_OS_MASTER();
     return true;
 }
 
@@ -867,6 +896,7 @@ void transactions_slave(matrix_row_t master_matrix[], matrix_row_t slave_matrix[
     TRANSACTIONS_POINTING_SLAVE();
     TRANSACTIONS_WATCHDOG_SLAVE();
     TRANSACTIONS_HAPTIC_SLAVE();
+    TRANSACTIONS_DETECTED_OS_SLAVE();
 }
 
 #if defined(SPLIT_TRANSACTION_IDS_KB) || defined(SPLIT_TRANSACTION_IDS_USER)

quantum/split_common/transport.h

@@ -133,6 +133,10 @@ typedef struct _rpc_sync_info_t {
 } rpc_sync_info_t;
 #endif // defined(SPLIT_TRANSACTION_IDS_KB) || defined(SPLIT_TRANSACTION_IDS_USER)
 
+#if defined(SPLIT_DETECTED_OS_ENABLE)
+#   include "os_detection.h"
+#endif // define(SPLIT_DETECTED_OS_ENABLE)
+
 typedef struct _split_shared_memory_t {
 #ifdef USE_I2C
     int8_t transaction_id;
@@ -209,6 +213,10 @@ typedef struct _split_shared_memory_t {
     uint8_t         rpc_m2s_buffer[RPC_M2S_BUFFER_SIZE];
     uint8_t         rpc_s2m_buffer[RPC_S2M_BUFFER_SIZE];
 #endif // defined(SPLIT_TRANSACTION_IDS_KB) || defined(SPLIT_TRANSACTION_IDS_USER)
+
+#if defined(SPLIT_DETECTED_OS_ENABLE)
+    os_variant_t detected_os;
+#endif // define(SPLIT_DETECTED_OS_ENABLE)
 } split_shared_memory_t;
 
 extern split_shared_memory_t *const split_shmem;