valentine

main.rs (11794B)

---

 //! Phase 0 feasibility spike for scarlett-tui.
 //!
 //! Goal: prove that on macOS we can speak the Focusrite "scarlett2" control
 //! protocol to a Scarlett 18i20 3rd Gen over endpoint 0, WITHOUT taking the
 //! audio streaming interfaces away from Core Audio — i.e. replicate what
 //! Focusrite Control does, from userspace, in Rust.
 //!
 //! It is deliberately chatty and defensive: every step prints what happened so
 //! we can read the real macOS behaviour rather than guess it.
 //!
 //! Run with Focusrite Control QUIT (only one process may own the device):
 //!     cargo run -p spike
 //!
 //! Protocol facts (from the GPL Linux driver sound/usb/mixer_scarlett2.c):
 //!   * control transfers on EP0, recipient = interface
 //!       TX: bmRequestType 0x21 (Class|Interface|OUT), bRequest 2 (CMD_REQ)
 //!       RX: bmRequestType 0xA1 (Class|Interface|IN),  bRequest 3 (CMD_RESP)
 //!   * 16-byte little-endian header: cmd u32, size u16, seq u16, error u32, pad u32
 //!   * seq increments by 1 per request; response echoes cmd/seq, error must be 0
 
 use std::time::Duration;
 
 use anyhow::{anyhow, bail, Context, Result};
 use rusb::{Direction, Recipient, RequestType, TransferType, UsbContext};
 
 const VID: u16 = 0x1235; // Focusrite / Novation
 const PID: u16 = 0x8215; // Scarlett 18i20 3rd Gen
 
 // scarlett2 opcodes
 const CMD_INIT_1: u32 = 0x0000_0000;
 const CMD_INIT_2: u32 = 0x0000_0002;
 const CMD_GET_SYNC: u32 = 0x0000_6004;
 const CMD_GET_DATA: u32 = 0x0080_0000;
 
 const REQ: u8 = 2; // CMD_REQ  (host -> device)
 const RESP: u8 = 3; // CMD_RESP (device -> host)
 const CMD_INIT: u8 = 0; // bRequest for the raw "step 0" priming read
 const HDR: usize = 16;
 const TIMEOUT: Duration = Duration::from_millis(1000);
 
 fn main() {
     if let Err(e) = run() {
         eprintln!("\n\x1b[31mSPIKE FAILED:\x1b[0m {e:#}");
         eprintln!("\nIf this is an access/ownership error, make sure Focusrite Control");
         eprintln!("is fully quit (it holds the device exclusively).");
         std::process::exit(1);
     }
 }
 
 fn run() -> Result<()> {
     let ctx = rusb::Context::new().context("create libusb context")?;
 
     let device = ctx
         .devices()?
         .iter()
         .find(|d| {
             d.device_descriptor()
                 .map(|x| x.vendor_id() == VID && x.product_id() == PID)
                 .unwrap_or(false)
         })
         .ok_or_else(|| anyhow!("Scarlett 18i20 3rd Gen ({VID:04x}:{PID:04x}) not found"))?;
 
     let desc = device.device_descriptor()?;
     println!("== Device ==");
     println!(
         "  {:04x}:{:04x}  bDeviceClass={:#04x} subclass={:#04x} configs={}",
         desc.vendor_id(),
         desc.product_id(),
         desc.class_code(),
         desc.sub_class_code(),
         desc.num_configurations()
     );
 
     // --- 1. Enumerate interfaces + endpoints; find the control interface and a
     //        candidate interrupt-in (notification) endpoint. ----------------
     let config = device
         .active_config_descriptor()
         .context("read active config descriptor")?;
 
     let mut control_iface: Option<u8> = None;
     let mut notify: Option<(u8, u8)> = None; // (interface number, endpoint address)
 
     println!("\n== Interfaces ==");
     for iface in config.interfaces() {
         for d in iface.descriptors() {
             let ifn = d.interface_number();
             let class = d.class_code();
             let sub = d.sub_class_code();
             println!(
                 "  iface {ifn} alt {}  class={class:#04x} subclass={sub:#04x} endpoints={}",
                 d.setting_number(),
                 d.num_endpoints()
             );
             // The scarlett2 control protocol (Gen3+) lives on the VENDOR-SPECIFIC
             // interface (class 0xFF) that carries the interrupt notify endpoint —
             // NOT the USB-Audio control interface. wIndex must be this interface.
             if class == 0xFF {
                 control_iface.get_or_insert(ifn);
             }
             for ep in d.endpoint_descriptors() {
                 let addr = ep.address();
                 let is_int = ep.transfer_type() == TransferType::Interrupt;
                 let is_in = ep.direction() == Direction::In;
                 println!(
                     "      ep {addr:#04x} {} {}",
                     if is_in { "IN " } else { "OUT" },
                     transfer_type_name(ep.transfer_type())
                 );
                 if is_int && is_in {
                     notify.get_or_insert((ifn, addr));
                 }
             }
         }
     }
 
     // Prefer the vendor-specific interface; otherwise whichever carries the
     // interrupt-in endpoint; last resort interface 0.
     let ctl_iface = control_iface.or(notify.map(|(i, _)| i)).unwrap_or(0);
     println!("\n  -> using control interface {ctl_iface}");
     if let Some((ifn, ep)) = notify {
         println!("  -> candidate notify endpoint {ep:#04x} on interface {ifn}");
     } else {
         println!("  -> no interrupt-in endpoint found (will rely on polling)");
     }
 
     // --- 2. Open the device. This is the first macOS gate: can a userspace app
     //        open the device while Core Audio drives the audio interfaces? ---
     let handle = device.open().context(
         "open device — if this fails with 'access denied' or 'busy', quit Focusrite Control",
     )?;
     println!("\n\x1b[32mOK\x1b[0m device opened (Core Audio should still be streaming)");
 
     // --- 3. scarlett2 INIT handshake over EP0 (mirrors the kernel exactly). ---
     //
     //   step 0: raw control-IN, bRequest = CMD_INIT (0) — primes the device.
     //   INIT_1: packet cmd 0, seq reset to 1 (the "seq sent=1, response=0" quirk).
     //   INIT_2: packet cmd 2, seq reset to 1; firmware version is u32 LE at byte 8.
     println!("\n== INIT step 0 (raw read, bRequest=0) ==");
     {
         let rt_in = rusb::request_type(Direction::In, RequestType::Class, Recipient::Interface);
         let mut buf = [0u8; 24];
         match handle.read_control(rt_in, CMD_INIT, 0, ctl_iface as u16, &mut buf, TIMEOUT) {
             Ok(n) => println!("  ok, {n} bytes: {}", hex(&buf[..n])),
             Err(e) => eprintln!("  step 0 failed (continuing): {e}"),
         }
     }
 
     let mut seq: u16 = 1;
 
     println!("\n== INIT_1 ==");
     // seq already 1
     match cmd(&handle, ctl_iface, &mut seq, CMD_INIT_1, &[], 0) {
         Ok(data) => println!("  ok ({} payload bytes){}", data.len(), maybe_hex(&data)),
         Err(e) => return Err(e).context("INIT_1 — the handshake gate"),
     }
 
     println!("\n== INIT_2 (device info / firmware) ==");
     seq = 1; // reset per kernel
     match cmd(&handle, ctl_iface, &mut seq, CMD_INIT_2, &[], 32) {
         Ok(data) => {
             println!("  ok, {} bytes: {}", data.len(), hex(&data));
             if data.len() >= 12 {
                 let fw = u32::from_le_bytes(data[8..12].try_into().unwrap());
                 println!("  \x1b[36mfirmware version: {fw}\x1b[0m");
             }
         }
         Err(e) => eprintln!("  INIT_2 failed (non-fatal for the gate): {e:#}"),
     }
 
     println!("\n== GET_SYNC (clock lock status) ==");
     match cmd(&handle, ctl_iface, &mut seq, CMD_GET_SYNC, &[], 16) {
         Ok(data) => println!("  ok, {} bytes: {}  (nonzero usually = locked)", data.len(), hex(&data)),
         Err(e) => eprintln!("  GET_SYNC failed: {e:#}"),
     }
 
     println!("\n== GET_DATA (read config offset 0, 8 bytes) ==");
     // GET_DATA payload = { offset: u32 LE, size: u32 LE }
     let mut p = Vec::new();
     p.extend_from_slice(&0u32.to_le_bytes()); // offset 0
     p.extend_from_slice(&8u32.to_le_bytes()); // 8 bytes
     match cmd(&handle, ctl_iface, &mut seq, CMD_GET_DATA, &p, 8) {
         Ok(data) => println!("  ok, {} bytes: {}", data.len(), hex(&data)),
         Err(e) => eprintln!("  GET_DATA failed: {e:#}"),
     }
 
     // --- 4. Notification endpoint: try to claim the interface and read it.
     //        On macOS this likely fails (kernel owns the audio interface) — in
     //        which case we fall back to polling, which is fine. ---------------
     if let Some((ifn, ep)) = notify {
         println!("\n== Notify endpoint (claim + interrupt read, 500ms) ==");
         match handle.claim_interface(ifn) {
             Ok(()) => {
                 println!("  claimed interface {ifn}; waiting for a notification...");
                 let mut buf = [0u8; 64];
                 match handle.read_interrupt(ep, &mut buf, Duration::from_millis(500)) {
                     Ok(n) => println!("  got {n} bytes: {}", hex(&buf[..n])),
                     Err(rusb::Error::Timeout) => {
                         println!("  no notification within 500ms (expected when idle)")
                     }
                     Err(e) => eprintln!("  interrupt read error: {e}"),
                 }
                 let _ = handle.release_interface(ifn);
             }
             Err(e) => {
                 println!(
                     "  could not claim interface {ifn}: {e}\n  -> EXPECTED on macOS; we'll use polling for live updates."
                 );
             }
         }
     }
 
     println!("\n\x1b[32mSPIKE PASSED\x1b[0m — EP0 control works; build the TUI on this foundation.");
     println!("Confirm audio kept playing throughout, then hand the device back to Focusrite Control if needed.");
     Ok(())
 }
 
 /// One scarlett2 request/response round-trip over EP0.
 fn cmd(
     handle: &rusb::DeviceHandle<rusb::Context>,
     iface: u8,
     seq: &mut u16,
     cmd: u32,
     payload: &[u8],
     resp_payload_cap: usize,
 ) -> Result<Vec<u8>> {
     let this_seq = *seq;
     *seq = seq.wrapping_add(1);
 
     // request packet: 16-byte header + payload
     let mut req = Vec::with_capacity(HDR + payload.len());
     req.extend_from_slice(&cmd.to_le_bytes());
     req.extend_from_slice(&(payload.len() as u16).to_le_bytes());
     req.extend_from_slice(&this_seq.to_le_bytes());
     req.extend_from_slice(&0u32.to_le_bytes()); // error
     req.extend_from_slice(&0u32.to_le_bytes()); // pad
     req.extend_from_slice(payload);
 
     let rt_out = rusb::request_type(Direction::Out, RequestType::Class, Recipient::Interface);
     handle
         .write_control(rt_out, REQ, 0, iface as u16, &req, TIMEOUT)
         .context("control OUT (CMD_REQ)")?;
 
     let mut buf = vec![0u8; HDR + resp_payload_cap];
     let rt_in = rusb::request_type(Direction::In, RequestType::Class, Recipient::Interface);
     let n = handle
         .read_control(rt_in, RESP, 0, iface as u16, &mut buf, TIMEOUT)
         .context("control IN (CMD_RESP)")?;
     buf.truncate(n);
 
     if n < HDR {
         bail!("short response: {n} bytes (< {HDR}-byte header)");
     }
     let r_cmd = u32::from_le_bytes(buf[0..4].try_into().unwrap());
     let r_size = u16::from_le_bytes(buf[4..6].try_into().unwrap());
     let r_seq = u16::from_le_bytes(buf[6..8].try_into().unwrap());
     let r_err = u32::from_le_bytes(buf[8..12].try_into().unwrap());
 
     if r_err != 0 {
         bail!("device error code {r_err:#x} (cmd {cmd:#x}, seq {this_seq})");
     }
     if r_cmd != cmd {
         eprintln!("  warn: response cmd {r_cmd:#x} != request {cmd:#x}");
     }
     if r_seq != this_seq {
         eprintln!("  warn: response seq {r_seq} != request {this_seq}");
     }
 
     let end = (HDR + r_size as usize).min(buf.len());
     Ok(buf[HDR..end].to_vec())
 }
 
 fn transfer_type_name(t: rusb::TransferType) -> &'static str {
     match t {
         rusb::TransferType::Control => "control",
         rusb::TransferType::Isochronous => "isochronous",
         rusb::TransferType::Bulk => "bulk",
         rusb::TransferType::Interrupt => "interrupt",
     }
 }
 
 fn hex(b: &[u8]) -> String {
     b.iter().map(|x| format!("{x:02x} ")).collect()
 }
 
 fn maybe_hex(b: &[u8]) -> String {
     if b.is_empty() {
         String::new()
     } else {
         format!(": {}", hex(b))
     }
 }