Update USB config tool for fm and midi

Author: sandlbn

src/device_config.rs

@@ -5,9 +5,24 @@
 
 use crate::player::{DeviceConfigCmd, DeviceConfigEdit};
 use crate::ui::DeviceConfigSnapshot;
+use usbsid_pico_config::protocol::{cfg as cfg_op, encode_packet};
 use usbsid_pico_config::transport::Transport;
 use usbsid_pico_config::Device;
 
+/// Send a single fire-and-forget config opcode (no response expected).
+/// Used for the diagnostic / hardware action commands the crate doesn't
+/// expose as named wrappers (TEST_SID, RESET_USBSID, MIDI state, etc.).
+fn send_cfg_opcode<T: Transport>(
+    dev: &mut Device<T>,
+    cmd: u8,
+    args: [u8; 4],
+) -> Result<(), String> {
+    let packet = encode_packet(cmd, args);
+    dev.transport_mut()
+        .send(&packet)
+        .map_err(|e| format!("send opcode {cmd:#04X}: {e}"))
+}
+
 /// Execute `op` against the device wrapped by `transport`. Returns
 /// `Some(snapshot)` only for `Refresh` (and as an after-effect of
 /// auto-detect, since callers will want the resulting config). For
@@ -73,6 +88,85 @@ pub fn run<T: Transport>(
             std::thread::sleep(std::time::Duration::from_millis(3500));
             refresh(&mut dev).map(Some)
         }
+
+        DeviceConfigCmd::Confirm => {
+            dev.confirm_config()
+                .map_err(|e| format!("confirm_config: {e}"))?;
+            refresh(&mut dev).map(Some)
+        }
+
+        DeviceConfigCmd::DetectSids => {
+            dev.detect_sids().map_err(|e| format!("detect_sids: {e}"))?;
+            std::thread::sleep(std::time::Duration::from_millis(1500));
+            refresh(&mut dev).map(Some)
+        }
+
+        DeviceConfigCmd::DetectClones => {
+            dev.detect_clones()
+                .map_err(|e| format!("detect_clones: {e}"))?;
+            std::thread::sleep(std::time::Duration::from_millis(2500));
+            refresh(&mut dev).map(Some)
+        }
+
+        DeviceConfigCmd::TestSid(which) => {
+            let cmd = match *which {
+                0 => cfg_op::TEST_ALLSIDS,
+                1 => cfg_op::TEST_SID1,
+                2 => cfg_op::TEST_SID2,
+                3 => cfg_op::TEST_SID3,
+                4 => cfg_op::TEST_SID4,
+                other => return Err(format!("TestSid: invalid SID index {other}")),
+            };
+            send_cfg_opcode(&mut dev, cmd, [0, 0, 0, 0])?;
+            Ok(None)
+        }
+
+        DeviceConfigCmd::StopTests => {
+            send_cfg_opcode(&mut dev, cfg_op::STOP_TESTS, [0, 0, 0, 0])?;
+            Ok(None)
+        }
+
+        DeviceConfigCmd::ResetUsbsid => {
+            send_cfg_opcode(&mut dev, cfg_op::RESET_USBSID, [0, 0, 0, 0])?;
+            // Device re-enumerates — drop the handle; the GUI will reconnect.
+            Ok(None)
+        }
+
+        DeviceConfigCmd::RestartBus => {
+            send_cfg_opcode(&mut dev, cfg_op::RESTART_BUS, [0, 0, 0, 0])?;
+            Ok(None)
+        }
+
+        DeviceConfigCmd::RestartBusClk => {
+            send_cfg_opcode(&mut dev, cfg_op::RESTART_BUS_CLK, [0, 0, 0, 0])?;
+            Ok(None)
+        }
+
+        DeviceConfigCmd::SyncPios => {
+            send_cfg_opcode(&mut dev, cfg_op::SYNC_PIOS, [0, 0, 0, 0])?;
+            Ok(None)
+        }
+
+        DeviceConfigCmd::SocketDetect => {
+            send_cfg_opcode(&mut dev, cfg_op::SOCKET_DETECT, [0, 0, 0, 0])?;
+            std::thread::sleep(std::time::Duration::from_millis(500));
+            refresh(&mut dev).map(Some)
+        }
+
+        DeviceConfigCmd::MidiLoadState => {
+            send_cfg_opcode(&mut dev, cfg_op::LOAD_MIDI_STATE, [0, 0, 0, 0])?;
+            Ok(None)
+        }
+
+        DeviceConfigCmd::MidiSaveState => {
+            send_cfg_opcode(&mut dev, cfg_op::SAVE_MIDI_STATE, [0, 0, 0, 0])?;
+            Ok(None)
+        }
+
+        DeviceConfigCmd::MidiResetState => {
+            send_cfg_opcode(&mut dev, cfg_op::RESET_MIDI_STATE, [0, 0, 0, 0])?;
+            Ok(None)
+        }
     }
 }
 
@@ -106,8 +200,17 @@ fn apply_edit(cfg: &mut usbsid_pico_config::DeviceConfig, edit: DeviceConfigEdit
         Flipped(v) => cfg.flipped = v,
         Mixed(v) => cfg.mixed = v,
         FmoplEnabled(v) => cfg.protocols.fmopl_enabled = v,
+        FmoplSidno(v) => cfg.protocols.fmopl_sidno = v,
         LockClockrate(v) => cfg.lock_clockrate = v,
         ExternalClock(v) => cfg.external_clock = v,
+        LedEnabled(v) => cfg.led.enabled = v,
+        LedIdleBreathe(v) => cfg.led.idle_breathe = v,
+        RgbLedEnabled(v) => cfg.rgb_led.enabled = v,
+        RgbLedIdleBreathe(v) => cfg.rgb_led.idle_breathe = v,
+        RgbLedBrightness(v) => cfg.rgb_led.brightness = v,
+        RgbLedSidToUse(v) => cfg.rgb_led.sid_to_use = v,
+        NeedConfirmation(v) => cfg.need_confirmation = v,
+        DisableChangeDetect(v) => cfg.disable_changedetect = v,
     }
 }
 

src/main.rs

@@ -1364,6 +1364,28 @@ impl App {
                 ));
             }
 
+            Message::DeviceConfigAction(cmd) => {
+                use player::DeviceConfigCmd as C;
+                self.device_cfg_status = match &cmd {
+                    C::Confirm => "Confirming config…".into(),
+                    C::DetectSids => "Detecting SIDs…".into(),
+                    C::DetectClones => "Detecting clones (≈2 s)…".into(),
+                    C::TestSid(0) => "Test tone: all SIDs".into(),
+                    C::TestSid(n) => format!("Test tone: SID{n}"),
+                    C::StopTests => "Stopping test tones".into(),
+                    C::ResetUsbsid => "Resetting USBSID — reconnecting…".into(),
+                    C::RestartBus => "Restarting SID bus".into(),
+                    C::RestartBusClk => "Restarting bus + clock".into(),
+                    C::SyncPios => "Sync PIOs".into(),
+                    C::SocketDetect => "Re-detecting sockets…".into(),
+                    C::MidiLoadState => "Loading MIDI state".into(),
+                    C::MidiSaveState => "Saving MIDI state".into(),
+                    C::MidiResetState => "Resetting MIDI state".into(),
+                    other => format!("Sending {other:?}…"),
+                };
+                let _ = self.cmd_tx.send(player::PlayerCmd::DeviceConfig(cmd));
+            }
+
             Message::DeviceConfigResult(result) => match result {
                 Ok(snap) => {
                     self.device_cfg = Some(snap);

src/player/mod.rs

@@ -73,6 +73,32 @@ pub enum DeviceConfigCmd {
     Reset,
     /// Trigger the firmware's full chip + SID detection.
     AutoDetect,
+    /// PCB v1.5+: confirm pending config so sockets become active.
+    Confirm,
+    /// Probe SID positions (firmware-detected). Lightweight vs AutoDetect.
+    DetectSids,
+    /// Probe SID clone types (ARMSID / SKPico / FPGASID / etc).
+    DetectClones,
+    /// Play a test tone. 0 = all SIDs, 1..=4 = specific SID.
+    TestSid(u8),
+    /// Stop any running test tones.
+    StopTests,
+    /// Soft-reset the USBSID-Pico firmware (re-enumerates over USB).
+    ResetUsbsid,
+    /// Re-init the SID bus.
+    RestartBus,
+    /// Re-init the SID bus AND re-derive the clock.
+    RestartBusClk,
+    /// Re-sync the PIO state machines.
+    SyncPios,
+    /// Re-run the socket detect routine (PCB v1.5+ presence detection).
+    SocketDetect,
+    /// MIDI state: load the saved state from flash.
+    MidiLoadState,
+    /// MIDI state: persist the current state to flash.
+    MidiSaveState,
+    /// MIDI state: reset to factory MIDI state.
+    MidiResetState,
 }
 
 /// One discrete edit a Device-tab control can dispatch. Each variant maps
@@ -92,8 +118,21 @@ pub enum DeviceConfigEdit {
     Flipped(bool),
     Mixed(bool),
     FmoplEnabled(bool),
+    /// FMopl SID selector. 0 = auto, 1..=4 = explicit SID.
+    FmoplSidno(u8),
     LockClockrate(bool),
     ExternalClock(bool),
+    // ── LED + RGB LED ──────────────────────────────────────────────
+    LedEnabled(bool),
+    LedIdleBreathe(bool),
+    RgbLedEnabled(bool),
+    RgbLedIdleBreathe(bool),
+    RgbLedBrightness(u8),
+    /// RGB LED → SID-to-use. -1 = off, 1..=4 = SID index.
+    RgbLedSidToUse(i8),
+    // ── PCB v1.5+ flags ────────────────────────────────────────────
+    NeedConfirmation(bool),
+    DisableChangeDetect(bool),
 }
 
 /// Status updates sent from player thread → GUI.
@@ -1191,6 +1230,27 @@ fn handle_cmd(
                 let _ = device_cfg_tx.try_send(Err(e));
                 return;
             }
+            // ── Quiesce playback before talking config ────────────────────
+            // The driver's threaded writer drains the ring buffer and
+            // locks the same USB endpoint our config commands use. If
+            // SID writes interleave with our SET_CONFIG packets the
+            // firmware can re-engage a socket we just disabled, or
+            // stall responding to READ_CONFIG — the "disable doesn't
+            // work / freezes" symptom reported via email.
+            //
+            // We're already on the player thread, so processing this
+            // command means no new frames are being pushed to the ring
+            // for the duration of the config op. Flushing the ring +
+            // a brief idle lets the writer thread drain whatever's
+            // still queued before we take over the endpoint. The next
+            // playback frame after we return will refill the ring.
+            if matches!(state, PlayState::Playing) {
+                if let Some(br) = bridge.as_mut() {
+                    br.flush();
+                    std::thread::sleep(std::time::Duration::from_millis(30));
+                }
+            }
+
             let result = match bridge.as_mut() {
                 Some(br) => br.run_device_config(&op),
                 None => Err("device not initialised".into()),