diff --git a/services/codec/src/api.rs b/services/codec/src/api.rs index c19f5fafe..a7852f8d6 100644 --- a/services/codec/src/api.rs +++ b/services/codec/src/api.rs @@ -1,4 +1,4 @@ -pub(crate) const SERVER_NAME_CODEC: &str = "_Low-level Audio Codec Server_"; +pub(crate) const SERVER_NAME_CODEC: &str = "_Low-level Audio Codec Server_"; #[allow(dead_code)] #[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)] @@ -24,9 +24,11 @@ pub(crate) enum Opcode { /// Powers on the CODEC, sets up 8k stereo streaming; puts audio in "paused" state Setup8kStereo, - /// Pause the stream without powering anything off. Will wait until the current playback frames in process are finished. + /// Pause the stream without powering anything off. Will wait until the current playback frames in + /// process are finished. PauseStream, - /// Pause the stream without powering anything off. Clears the buffer immediately, losing any frames in playback. + /// Pause the stream without powering anything off. Clears the buffer immediately, losing any frames in + /// playback. AbortStream, /// Resumes the stream withouth re-initializing anything @@ -69,7 +71,6 @@ pub enum VolumeOps { RestoreDefault, } - #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] pub(crate) enum EventCallback { Event, @@ -79,8 +80,10 @@ pub(crate) enum EventCallback { #[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)] pub(crate) struct ScalarHook { pub sid: (u32, u32, u32, u32), - pub id: u32, // ID of the scalar message to send through (e.g. the discriminant of the Enum on the caller's side API) - pub cid: xous::CID, // caller-side connection ID for the scalar message to route to. Created by the caller before hooking. + pub id: u32, /* ID of the scalar message to send through (e.g. the discriminant of the Enum on the + * caller's side API) */ + pub cid: xous::CID, /* caller-side connection ID for the scalar message to route to. Created by the + * caller before hooking. */ } ////////////////////////////////////////////////////////////////////////////////////// @@ -128,31 +131,30 @@ impl FrameRing { auth_token: None, } } + pub fn clear(&mut self) { self.buffer = [[(ZERO_PCM as u32 | (ZERO_PCM as u32) << 16); FIFO_DEPTH]; FRAMES]; self.rd_frame = 0; self.wr_frame = 0; self.rec_ptr = 0; } + pub fn reset_ptrs(&mut self) { self.rd_frame = 0; self.wr_frame = 0; self.rec_ptr = 0; } + /* empty: rd_frame == wr_frame full: wr_frame == (rd_frame - 1) || (rd_frame == 0) && (wr_frame == F-1) */ - pub fn is_empty(&self) -> bool { - self.rd_frame == self.wr_frame - } + pub fn is_empty(&self) -> bool { self.rd_frame == self.wr_frame } + pub fn is_full(&self) -> bool { - if self.rd_frame == 0 { - self.wr_frame == FRAMES-1 - } else { - self.wr_frame == (self.rd_frame - 1) - } + if self.rd_frame == 0 { self.wr_frame == FRAMES - 1 } else { self.wr_frame == (self.rd_frame - 1) } } + pub fn readable_count(&self) -> usize { if self.wr_frame >= self.rd_frame { self.wr_frame - self.rd_frame @@ -160,10 +162,11 @@ impl FrameRing { self.wr_frame + FRAMES - self.rd_frame } } - pub fn writeable_count(&self) -> usize { - (FRAMES-1) - self.readable_count() - } - // this is less time efficient, but more space efficient, as we don't allocate intermediate buffers, clear them, etc. + + pub fn writeable_count(&self) -> usize { (FRAMES - 1) - self.readable_count() } + + // this is less time efficient, but more space efficient, as we don't allocate intermediate buffers, clear + // them, etc. pub fn rec_sample(&mut self, sample: u32) -> bool { if self.rec_ptr < FIFO_DEPTH { self.buffer[self.wr_frame][self.rec_ptr] = sample; @@ -173,6 +176,7 @@ impl FrameRing { false } } + pub fn rec_advance(&mut self) -> bool { if self.is_full() { false @@ -182,6 +186,7 @@ impl FrameRing { true } } + pub fn nq_frame(&mut self, frame: [u32; FIFO_DEPTH]) -> Result<(), [u32; FIFO_DEPTH]> { if self.is_full() { return Err(frame); @@ -194,6 +199,7 @@ impl FrameRing { self.rec_ptr = 0; Ok(()) } + pub fn dq_frame(&mut self) -> Option<[u32; FIFO_DEPTH]> { if self.is_empty() { None diff --git a/services/codec/src/backend/hostaudio.rs b/services/codec/src/backend/hostaudio.rs index 5f47f3bf2..09bd7a0ea 100644 --- a/services/codec/src/backend/hostaudio.rs +++ b/services/codec/src/backend/hostaudio.rs @@ -2,95 +2,60 @@ use codec::FIFO_DEPTH; -pub struct Codec { -} +pub struct Codec {} impl Codec { - pub fn new(_conn: xous::CID, _xns: &xous_names::XousNames) -> Codec { - Codec { - } - } - pub fn suspend(&self) { - } - pub fn resume(&self) { - } - pub fn init(&mut self) { - } + pub fn new(_conn: xous::CID, _xns: &xous_names::XousNames) -> Codec { Codec {} } - pub fn nq_play_frame(&mut self, _frame: [u32; FIFO_DEPTH]) -> Result<(), [u32; FIFO_DEPTH]> { - Ok(()) - } - pub fn dq_rec_frame(&mut self) -> Option<[u32; FIFO_DEPTH]> { - None - } - pub fn free_play_frames(&self) -> usize { - 0 - } + pub fn suspend(&self) {} - pub fn can_play(&self) -> bool { - false - } + pub fn resume(&self) {} - pub fn drain(&mut self) { - } + pub fn init(&mut self) {} - pub fn available_rec_frames(&self) -> usize { - 0 - } + pub fn nq_play_frame(&mut self, _frame: [u32; FIFO_DEPTH]) -> Result<(), [u32; FIFO_DEPTH]> { Ok(()) } - pub fn power(&mut self, _state: bool) { - } + pub fn dq_rec_frame(&mut self) -> Option<[u32; FIFO_DEPTH]> { None } - pub fn is_on(&self) -> bool { - false - } - pub fn is_init(&self) -> bool { - true - } - pub fn is_live(&self) -> bool { - false - } + pub fn free_play_frames(&self) -> usize { 0 } - pub fn get_headset_code(&mut self) -> u8 { - 0 - } + pub fn can_play(&self) -> bool { false } - pub fn get_dacflag_code(&mut self) -> u8 { - 0 - } + pub fn drain(&mut self) {} - pub fn get_hp_status(&mut self) -> u8 { - 0 - } + pub fn available_rec_frames(&self) -> usize { 0 } - pub fn get_i2s_config(&mut self) -> [u8; 4] { - [0, 0, 0, 0] - } + pub fn power(&mut self, _state: bool) {} - pub fn audio_clocks(&mut self) { - } + pub fn is_on(&self) -> bool { false } - pub fn audio_ports(&mut self) { - } + pub fn is_init(&self) -> bool { true } - pub fn audio_loopback(&mut self, _do_loop:bool) { - } + pub fn is_live(&self) -> bool { false } + + pub fn get_headset_code(&mut self) -> u8 { 0 } + + pub fn get_dacflag_code(&mut self) -> u8 { 0 } + + pub fn get_hp_status(&mut self) -> u8 { 0 } + + pub fn get_i2s_config(&mut self) -> [u8; 4] { [0, 0, 0, 0] } + + pub fn audio_clocks(&mut self) {} + + pub fn audio_ports(&mut self) {} + + pub fn audio_loopback(&mut self, _do_loop: bool) {} /// set up the audio mixer to sane defaults - pub fn audio_mixer(&mut self) { - } + pub fn audio_mixer(&mut self) {} /// set up the betrusted-side signals - pub fn audio_i2s_start(&mut self) { - } + pub fn audio_i2s_start(&mut self) {} - pub fn audio_i2s_stop(&mut self) { - } + pub fn audio_i2s_stop(&mut self) {} - pub fn set_speaker_gain_db(&mut self, _gain_db: f32) { - } - - pub fn set_headphone_gain_db(&mut self, _gain_db_l: f32, _gain_db_r: f32) { - } + pub fn set_speaker_gain_db(&mut self, _gain_db: f32) {} + pub fn set_headphone_gain_db(&mut self, _gain_db_l: f32, _gain_db_r: f32) {} } diff --git a/services/codec/src/backend/mod.rs b/services/codec/src/backend/mod.rs index 7f590448f..8530740bf 100644 --- a/services/codec/src/backend/mod.rs +++ b/services/codec/src/backend/mod.rs @@ -3,7 +3,7 @@ mod hostaudio; #[cfg(not(target_os = "xous"))] pub use crate::backend::hostaudio::*; -#[cfg(any(feature="precursor", feature="renode"))] +#[cfg(any(feature = "precursor", feature = "renode"))] mod tlv320aic3100; -#[cfg(any(feature="precursor", feature="renode"))] +#[cfg(any(feature = "precursor", feature = "renode"))] pub(crate) use crate::backend::tlv320aic3100::*; diff --git a/services/codec/src/backend/tlv320aic3100.rs b/services/codec/src/backend/tlv320aic3100.rs index 7bd2dd62d..7d1955c43 100644 --- a/services/codec/src/backend/tlv320aic3100.rs +++ b/services/codec/src/backend/tlv320aic3100.rs @@ -1,12 +1,14 @@ #![allow(dead_code)] +use core::sync::atomic::{AtomicBool, Ordering::SeqCst}; + +use llio::I2cStatus; +use num_traits::*; +use susres::{RegManager, RegOrField, SuspendResume}; use utralib::generated::*; use xous::MemoryRange; -use susres::{RegManager, RegOrField, SuspendResume}; -use llio::I2cStatus; + use crate::api::*; -use num_traits::*; -use core::sync::atomic::{AtomicBool, Ordering::SeqCst}; static INTERRUPT_HOOKED: AtomicBool = AtomicBool::new(false); @@ -16,7 +18,7 @@ const I2C_TIMEOUT: u32 = 50; pub struct Codec { csr: utralib::CSR, fifo: MemoryRange, - susres_manager: RegManager<{utra::audio::AUDIO_NUMREGS}>, + susres_manager: RegManager<{ utra::audio::AUDIO_NUMREGS }>, llio: llio::Llio, i2c: llio::I2c, ticktimer: ticktimer_server::Ticktimer, @@ -68,8 +70,12 @@ fn audio_handler(_irq_no: usize, arg: *mut usize) { for &stereo_sample in frame.iter() { if true { //// TODO - // there is some bug which is causing the right channel to be frame shifted left by one, but not the left....could be a hardware bug. - unsafe { volatile_audio.write_volatile((stereo_sample & 0xFFFF_0000) | ((stereo_sample & 0xFFFF) >> 1)) }; + // there is some bug which is causing the right channel to be frame shifted left by one, but + // not the left....could be a hardware bug. + unsafe { + volatile_audio + .write_volatile((stereo_sample & 0xFFFF_0000) | ((stereo_sample & 0xFFFF) >> 1)) + }; } else { unsafe { volatile_audio.write_volatile(stereo_sample) }; } @@ -89,19 +95,22 @@ fn audio_handler(_irq_no: usize, arg: *mut usize) { let mut rec_buf: [u32; FIFO_DEPTH] = [ZERO_PCM as u32 | (ZERO_PCM as u32) << 16; FIFO_DEPTH]; for stereo_sample in rec_buf.iter_mut() { - unsafe{ *stereo_sample = volatile_audio.read_volatile(); } + unsafe { + *stereo_sample = volatile_audio.read_volatile(); + } } match codec.rec_buffer.nq_frame(rec_buf) { - Ok(()) => {}, - Err(_buff) => { - codec.rec_frames_dropped += 1 - }, + Ok(()) => {} + Err(_buff) => codec.rec_frames_dropped += 1, } // if the buffer is low, let the audio handler know we used up another frame! if codec.play_buffer.readable_count() < 6 && !codec.drain { - xous::try_send_message(codec.conn, - xous::Message::new_scalar(Opcode::AnotherFrame.to_usize().unwrap(), rx_rdcount, rx_wrcount, 0, 0)).unwrap(); + xous::try_send_message( + codec.conn, + xous::Message::new_scalar(Opcode::AnotherFrame.to_usize().unwrap(), rx_rdcount, rx_wrcount, 0, 0), + ) + .unwrap(); } codec.csr.wfo(utra::audio::EV_PENDING_RX_READY, 1); @@ -153,13 +162,24 @@ impl Codec { fn trace(&mut self) { if self.tx_stat_errors > 0 || self.rx_stat_errors > 0 { - log::trace!("drop p:{} r:{} | staterr tx:{} rx:{}", self.play_frames_dropped, self.rec_frames_dropped, self.tx_stat_errors, self.rx_stat_errors); + log::trace!( + "drop p:{} r:{} | staterr tx:{} rx:{}", + self.play_frames_dropped, + self.rec_frames_dropped, + self.tx_stat_errors, + self.rx_stat_errors + ); self.tx_stat_errors = 0; self.rx_stat_errors = 0; } } + fn trace_rx(&self) { - log::trace!("T rd {} wr {}", self.csr.rf(utra::audio::RX_STAT_RDCOUNT), self.csr.rf(utra::audio::RX_STAT_WRCOUNT)); + log::trace!( + "T rd {} wr {}", + self.csr.rf(utra::audio::RX_STAT_RDCOUNT), + self.csr.rf(utra::audio::RX_STAT_WRCOUNT) + ); } pub fn suspend(&mut self) { @@ -168,6 +188,7 @@ impl Codec { self.llio.audio_on(false).unwrap(); // force the codec into an off state for resume } } + pub fn resume(&mut self) { self.ticktimer.sleep_ms(470).unwrap(); // audio code resume has the lowest priority, it should only resume after most other activities stabilized if self.powered_on { @@ -186,12 +207,8 @@ impl Codec { pub fn init(&mut self) { // this should only be called once per reboot if !INTERRUPT_HOOKED.swap(true, SeqCst) { - xous::claim_interrupt( - utra::audio::AUDIO_IRQ, - audio_handler, - self as *mut Codec as *mut usize, - ) - .expect("couldn't claim audio irq"); + xous::claim_interrupt(utra::audio::AUDIO_IRQ, audio_handler, self as *mut Codec as *mut usize) + .expect("couldn't claim audio irq"); self.csr.wfo(utra::audio::EV_PENDING_RX_READY, 1); self.susres_manager.push(RegOrField::Reg(utra::audio::RX_CTL), None); @@ -217,21 +234,16 @@ impl Codec { pub fn nq_play_frame(&mut self, frame: [u32; FIFO_DEPTH]) -> Result<(), [u32; FIFO_DEPTH]> { self.play_buffer.nq_frame(frame) } - pub fn dq_rec_frame(&mut self) -> Option<[u32; FIFO_DEPTH]> { - self.rec_buffer.dq_frame() - } - pub fn free_play_frames(&self) -> usize { - self.play_buffer.writeable_count() - } - pub fn can_play(&self) -> bool { - !self.play_buffer.is_empty() - } - pub fn drain(&mut self) { - self.drain = true; - } - pub fn available_rec_frames(&self) -> usize { - self.rec_buffer.readable_count() - } + + pub fn dq_rec_frame(&mut self) -> Option<[u32; FIFO_DEPTH]> { self.rec_buffer.dq_frame() } + + pub fn free_play_frames(&self) -> usize { self.play_buffer.writeable_count() } + + pub fn can_play(&self) -> bool { !self.play_buffer.is_empty() } + + pub fn drain(&mut self) { self.drain = true; } + + pub fn available_rec_frames(&self) -> usize { self.rec_buffer.readable_count() } pub fn power(&mut self, state: bool) { self.llio.audio_on(state).expect("couldn't set audio power state"); @@ -241,15 +253,11 @@ impl Codec { } } - pub fn is_on(&self) -> bool { - self.powered_on - } - pub fn is_init(&self) -> bool { - self.initialized - } - pub fn is_live(&self) -> bool { - self.live - } + pub fn is_on(&self) -> bool { self.powered_on } + + pub fn is_init(&self) -> bool { self.initialized } + + pub fn is_live(&self) -> bool { self.live } pub fn set_speaker_gain_db(&mut self, gain_db: f32) { self.i2c.i2c_mutex_acquire(); @@ -262,9 +270,7 @@ impl Codec { let code = analog_volume_db_to_code(gain_db); self.w(0, &[1]); // select page 1 self.w(32, &[0b1_0_00011_0]); // class D amp powered on - self.w(38, &[ - 0b1_000_0000 | code, - ]); + self.w(38, &[0b1_000_0000 | code]); } self.i2c.i2c_mutex_release(); } @@ -282,14 +288,19 @@ impl Codec { let code_right = analog_volume_db_to_code(gain_db_right); self.w(0, &[1]); // select page 1 self.w(31, &[0b1_1_00011_0]); // headphones powered up - self.w(36, &[ - 0b1_000_0000 | code_left, // HPL - 0b1_000_0000 | code_right, // HPR - ]); + self.w( + 36, + &[ + 0b1_000_0000 | code_left, // HPL + 0b1_000_0000 | code_right, // HPR + ], + ); } self.i2c.i2c_mutex_release(); } - /// Convenience wrapper for I2C transactions. Multiple I2C ops that have to be execute atomically must be manually guarded with a i2c_mutex_[acquire/release] + + /// Convenience wrapper for I2C transactions. Multiple I2C ops that have to be execute atomically must be + /// manually guarded with a i2c_mutex_[acquire/release] fn w(&mut self, adr: u8, data: &[u8]) -> bool { // log::info!("writing to 0x{:x}, {:x?}", adr, data); match self.i2c.i2c_write(TLV320AIC3100_I2C_ADR, adr, data) { @@ -298,23 +309,35 @@ impl Codec { match status { I2cStatus::ResponseWriteOk => true, I2cStatus::ResponseBusy => false, - _ => {log::error!("try_send_i2c unhandled response: {:?}", status); false}, + _ => { + log::error!("try_send_i2c unhandled response: {:?}", status); + false + } } } - _ => {log::error!("try_send_i2c unhandled error"); false} + _ => { + log::error!("try_send_i2c unhandled error"); + false + } } } - /// Convenience wrapper for I2C transactions. Multiple I2C ops that have to be execute atomically must be manually guarded with a i2c_mutex_[acquire/release] - fn r(&mut self, adr: u8, data: &mut[u8]) -> bool { + + /// Convenience wrapper for I2C transactions. Multiple I2C ops that have to be execute atomically must be + /// manually guarded with a i2c_mutex_[acquire/release] + fn r(&mut self, adr: u8, data: &mut [u8]) -> bool { match self.i2c.i2c_read(TLV320AIC3100_I2C_ADR, adr, data) { - Ok(status) => { - match status { - I2cStatus::ResponseReadOk => true, - I2cStatus::ResponseBusy => false, - _ => {log::error!("try_send_i2c unhandled response: {:?}", status); false}, + Ok(status) => match status { + I2cStatus::ResponseReadOk => true, + I2cStatus::ResponseBusy => false, + _ => { + log::error!("try_send_i2c unhandled response: {:?}", status); + false } + }, + _ => { + log::error!("try_send_i2c unhandled error"); + false } - _ => {log::error!("try_send_i2c unhandled error"); false} } } @@ -369,41 +392,50 @@ impl Codec { /// oversampling rate (OSR) = 128 /// local divider = 12 /// 8_000 * 128 * 12 = 12_288_000 Hz - /// fn audio_clocks(&mut self) { self.i2c.i2c_mutex_acquire(); - self.w(0, &[0]); // select page 0 - self.w(1, &[1]); // software reset + self.w(0, &[0]); // select page 0 + self.w(1, &[1]); // software reset self.ticktimer.sleep_ms(2).unwrap(); // reset happens in 1 ms; +1 ms due to timing jitter uncertainty - self.w(0, &[0]); // select page 0 + self.w(0, &[0]); // select page 0 // select PLL_CLKIN = MCLK; CODEC_CLKIN = PLL_CLK self.w(4, &[0b0000_0011]); // fs = 8kHz // PLL_CLKIN = 12MHz - // PLLP = 1, PLLR = 1, PLLJ = 7, PLLD = 1680, NDAC = *12*, MDAC = 7, DOSR = 128, MADC = 2 , NADC = *42* - // ^^ from page 68 of datasheet, fs=48kHz/12MHz clkin line, with *bold* items multiplied by 6 to get to 8kHz - self.w(5, &[ - 0b1001_0001, // P, R = 1, 1 and pll powered up - 7, // PLLJ = 7 - ((1680 >> 8) & 0xFF) as u8, // D MSB of 1680 - (1680 & 0xFF) as u8, // D LSB of 1680 - ]); + // PLLP = 1, PLLR = 1, PLLJ = 7, PLLD = 1680, NDAC = *12*, MDAC = 7, DOSR = 128, MADC = 2 , NADC = + // *42* ^^ from page 68 of datasheet, fs=48kHz/12MHz clkin line, with *bold* items multiplied + // by 6 to get to 8kHz + self.w( + 5, + &[ + 0b1001_0001, // P, R = 1, 1 and pll powered up + 7, // PLLJ = 7 + ((1680 >> 8) & 0xFF) as u8, // D MSB of 1680 + (1680 & 0xFF) as u8, // D LSB of 1680 + ], + ); - self.w(11, &[ - 0x80 | 12, // NADC = 12 (set to 2 for 48kHz) - 0x80 | 7, // MDAC = 7 - 0, // DOSR = MSB of 128 - 128, // DOSR = LSB of 128 - ]); + self.w( + 11, + &[ + 0x80 | 12, // NADC = 12 (set to 2 for 48kHz) + 0x80 | 7, // MDAC = 7 + 0, // DOSR = MSB of 128 + 128, // DOSR = LSB of 128 + ], + ); - self.w(18, &[ - 0x80 | 42, // NADC = 42 (set to 7 for 48kHz) - 0x80 | 2, // MADC = 2 - 128, // AOSR = 128 - ]); + self.w( + 18, + &[ + 0x80 | 42, // NADC = 42 (set to 7 for 48kHz) + 0x80 | 2, // MADC = 2 + 128, // AOSR = 128 + ], + ); self.i2c.i2c_mutex_release(); } @@ -417,12 +449,16 @@ impl Codec { // 32 bits/word * 2 channels * 8000 samples/s = 512_000 = BCLK // pick off of DAC_MOD_CLK = 1.024MHz - self.w(27, &[ - 0b00_00_1_1_0_1, // I2S standard, 16 bits per sample, BCLK output, WCLK output, DOUT is Hi-Z when unused - 0b0, // no offset on left justification - 0b0000_0_1_01, // BDIV_CLKIN = DAC_MOD_CLK, BCLK active even when powered down - 0b1000_0010 // BCLK_N_VAL = 2, N divider is powered up - ]); + self.w( + 27, + &[ + 0b00_00_1_1_0_1, /* I2S standard, 16 bits per sample, BCLK output, WCLK output, DOUT is + * Hi-Z when unused */ + 0b0, // no offset on left justification + 0b0000_0_1_01, // BDIV_CLKIN = DAC_MOD_CLK, BCLK active even when powered down + 0b1000_0010, // BCLK_N_VAL = 2, N divider is powered up + ], + ); // "word width" (WCLK) timing is implied based on the DAC fs computed // at the end of the clock tree, and WCLK simply toggles every other sample, so there is no @@ -431,14 +467,14 @@ impl Codec { // turn on headset detection self.w(0, &[0]); // select page 0 // detection enabled, 64ms glitch reject, 8ms button glitch reject - self.w(67, &[0b1_00_010_01] ); + self.w(67, &[0b1_00_010_01]); // use auto volume control -- DO WE WANT THIS??? //self.w(116, &[0b1_1_01_0_001] ); self.i2c.i2c_mutex_release(); } - pub fn audio_loopback(&mut self, do_loop:bool) { + pub fn audio_loopback(&mut self, do_loop: bool) { self.i2c.i2c_mutex_acquire(); self.w(0, &[1]); // select page 1 @@ -473,20 +509,27 @@ impl Codec { //self.w(35, &[0b01_0_1_01_1_0]); // internal volume control - self.w(36, &[ - 0b1_001_1110, // HPL channel control on, -15dB - 0b1_001_1110, // HPR channel control on, -15dB - 0b1_000_1100, // SPK control on, -6dB - ]); + self.w( + 36, + &[ + 0b1_001_1110, // HPL channel control on, -15dB + 0b1_001_1110, // HPR channel control on, -15dB + 0b1_000_1100, // SPK control on, -6dB + ], + ); // driver PGA control - self.w(40, &[ - 0b0_0011_111, // HPL driver PGA = 3dB, not muted, all gains applied - 0b0_0011_111, // HPR driver PGA = 3dB, not muted, all gains applied - 0b000_01_1_0_1, // SPK gain = 12 dB, driver not muted, all gains applied - ]); + self.w( + 40, + &[ + 0b0_0011_111, // HPL driver PGA = 3dB, not muted, all gains applied + 0b0_0011_111, // HPR driver PGA = 3dB, not muted, all gains applied + 0b000_01_1_0_1, // SPK gain = 12 dB, driver not muted, all gains applied + ], + ); - // HP driver control -- 16us short circuit debounce, best DAC performance, HPL/HPR as headphone drivers + // HP driver control -- 16us short circuit debounce, best DAC performance, HPL/HPR as headphone + // drivers self.w(44, &[0b010_11_0_0_0]); // MICBIAS control -- micbias always on, set to 2.5V @@ -520,15 +563,18 @@ impl Codec { // ADC digital volume control coarse adjust self.w(83, &[0b0]); // +0.0 dB - self.w(86, &[ - 0b1_011_0000, // AGC enabled, target level = -12dB - 0b00_10101_0, // hysteresis 1dB, noise threshold = -((value-1)*2 + 30): 21 => -70dB - 100, // max gain = code/2 dB - 0b_00010_000, // attack time = 0b_acode_mul = (acode*32*mul)/Fs - 0b_01101_000, // decay time = 0b_dcode_mul = (dcode*32*mul)/Fs - 0x01, // noise debounce time = code*4 / fs - 0x01, // signal debounce time = code*4 / fs - ]); + self.w( + 86, + &[ + 0b1_011_0000, // AGC enabled, target level = -12dB + 0b00_10101_0, // hysteresis 1dB, noise threshold = -((value-1)*2 + 30): 21 => -70dB + 100, // max gain = code/2 dB + 0b_00010_000, // attack time = 0b_acode_mul = (acode*32*mul)/Fs + 0b_01101_000, // decay time = 0b_dcode_mul = (dcode*32*mul)/Fs + 0x01, // noise debounce time = code*4 / fs + 0x01, // signal debounce time = code*4 / fs + ], + ); self.i2c.i2c_mutex_release(); } @@ -539,8 +585,10 @@ impl Codec { self.csr.wfo(utra::audio::TX_CTL_RESET, 1); */ let volatile_audio = self.fifo.as_mut_ptr() as *mut u32; - for _ in 0..FIFO_DEPTH*2 { - unsafe { (volatile_audio).write(ZERO_PCM as u32 | (ZERO_PCM as u32) << 16); } // prefill TX fifo with zero's + for _ in 0..FIFO_DEPTH * 2 { + unsafe { + (volatile_audio).write(ZERO_PCM as u32 | (ZERO_PCM as u32) << 16); + } // prefill TX fifo with zero's } // enable interrupts on the RX_READY @@ -561,8 +609,13 @@ impl Codec { self.csr.wfo(utra::audio::RX_CTL_ENABLE, 0); self.csr.wfo(utra::audio::TX_CTL_ENABLE, 0); - log::info!("playback stopped. frames dropped: p{} r{} / errors: tx{} rx{}", - self.play_frames_dropped, self.rec_frames_dropped, self.tx_stat_errors, self.rx_stat_errors); + log::info!( + "playback stopped. frames dropped: p{} r{} / errors: tx{} rx{}", + self.play_frames_dropped, + self.rec_frames_dropped, + self.tx_stat_errors, + self.rx_stat_errors + ); self.play_frames_dropped = 0; self.rec_frames_dropped = 0; self.tx_stat_errors = 0; @@ -577,21 +630,37 @@ impl Codec { } /// this is a testing-only function which does a double-buffered audio loopback - pub fn audio_loopback_poll(&mut self, buf_a: &mut [u32; FIFO_DEPTH], buf_b: &mut [u32; FIFO_DEPTH], toggle: bool) -> bool { + pub fn audio_loopback_poll( + &mut self, + buf_a: &mut [u32; FIFO_DEPTH], + buf_b: &mut [u32; FIFO_DEPTH], + toggle: bool, + ) -> bool { let volatile_audio = self.fifo.as_mut_ptr() as *mut u32; - if (self.csr.rf(utra::audio::TX_STAT_FREE) == 1) && (self.csr.rf(utra::audio::RX_STAT_DATAREADY) == 1) { + if (self.csr.rf(utra::audio::TX_STAT_FREE) == 1) && (self.csr.rf(utra::audio::RX_STAT_DATAREADY) == 1) + { for i in 0..FIFO_DEPTH { if toggle { - unsafe{ buf_a[i] = *volatile_audio; } - unsafe { *volatile_audio = buf_b[i]; } + unsafe { + buf_a[i] = *volatile_audio; + } + unsafe { + *volatile_audio = buf_b[i]; + } } else { - unsafe{ buf_b[i] = *volatile_audio; } - unsafe { *volatile_audio = buf_a[i]; } + unsafe { + buf_b[i] = *volatile_audio; + } + unsafe { + *volatile_audio = buf_a[i]; + } } } // wait for the done flags to clear; with an interrupt-driven system, this isn't necessary - while (self.csr.rf(utra::audio::TX_STAT_FREE) == 1) & (self.csr.rf(utra::audio::RX_STAT_DATAREADY) == 1) {} + while (self.csr.rf(utra::audio::TX_STAT_FREE) == 1) + & (self.csr.rf(utra::audio::RX_STAT_DATAREADY) == 1) + {} // indicate we had an audio event true } else { diff --git a/services/codec/src/lib.rs b/services/codec/src/lib.rs index 97e1b4e4c..491a807f9 100644 --- a/services/codec/src/lib.rs +++ b/services/codec/src/lib.rs @@ -1,10 +1,10 @@ #![cfg_attr(target_os = "none", no_std)] pub mod api; -use xous::{CID, send_message, Message}; -use num_traits::{ToPrimitive, FromPrimitive}; -use xous_ipc::Buffer; pub use api::*; +use num_traits::{FromPrimitive, ToPrimitive}; +use xous::{send_message, Message, CID}; +use xous_ipc::Buffer; /// This is a keyword reserved for the "arg4" slot of a scalar callback, where args are numbered 1-4. pub const AUDIO_CB_ROUTING_ID: usize = 0; @@ -16,48 +16,49 @@ pub struct Codec { impl Codec { pub fn new(xns: &xous_names::XousNames) -> Result { REFCOUNT.fetch_add(1, Ordering::Relaxed); - let conn = xns.request_connection_blocking(api::SERVER_NAME_CODEC).expect("Can't connect to Codec server"); - Ok(Codec { - conn, - frame_sid: None, - }) + let conn = + xns.request_connection_blocking(api::SERVER_NAME_CODEC).expect("Can't connect to Codec server"); + Ok(Codec { conn, frame_sid: None }) } + pub fn hook_frame_callback(&mut self, id: u32, cid: CID) -> Result<(), xous::Error> { if self.frame_sid.is_none() { let sid = xous::create_server().unwrap(); self.frame_sid = Some(sid); let sid_tuple = sid.to_u32(); - xous::create_thread_4(frame_cb_server, sid_tuple.0 as usize, sid_tuple.1 as usize, sid_tuple.2 as usize, sid_tuple.3 as usize).unwrap(); - let hookdata = ScalarHook { - sid: sid_tuple, - id, - cid, - }; + xous::create_thread_4( + frame_cb_server, + sid_tuple.0 as usize, + sid_tuple.1 as usize, + sid_tuple.2 as usize, + sid_tuple.3 as usize, + ) + .unwrap(); + let hookdata = ScalarHook { sid: sid_tuple, id, cid }; let buf = Buffer::into_buf(hookdata).or(Err(xous::Error::InternalError))?; - buf.lend(self.conn, Opcode::AudioStreamSubscribe.to_u32().unwrap()).map(|_|()) + buf.lend(self.conn, Opcode::AudioStreamSubscribe.to_u32().unwrap()).map(|_| ()) } else { Err(xous::Error::MemoryInUse) // can't hook it twice } } pub fn setup_8k_stream(&mut self) -> Result<(), xous::Error> { - send_message(self.conn, - Message::new_scalar(Opcode::Setup8kStereo.to_usize().unwrap(), 0, 0, 0, 0) - ).map(|_| ()) + send_message(self.conn, Message::new_scalar(Opcode::Setup8kStereo.to_usize().unwrap(), 0, 0, 0, 0)) + .map(|_| ()) } + pub fn power_off(&mut self) -> Result<(), xous::Error> { - send_message(self.conn, - Message::new_scalar(Opcode::PowerOff.to_usize().unwrap(), 0, 0, 0, 0) - ).map(|_| ()) + send_message(self.conn, Message::new_scalar(Opcode::PowerOff.to_usize().unwrap(), 0, 0, 0, 0)) + .map(|_| ()) } pub fn free_frames(&mut self) -> Result<(usize, usize), xous::Error> { - let response = send_message(self.conn, - Message::new_blocking_scalar(Opcode::FreeFrames.to_usize().unwrap(), 0, 0, 0, 0))?; + let response = send_message( + self.conn, + Message::new_blocking_scalar(Opcode::FreeFrames.to_usize().unwrap(), 0, 0, 0, 0), + )?; if let xous::Result::Scalar2(play_free, rec_avail) = response { - Ok( - (play_free, rec_avail) - ) + Ok((play_free, rec_avail)) } else { log::error!("unexpected return value: {:#?}", response); Err(xous::Error::InternalError) @@ -73,64 +74,64 @@ impl Codec { } pub fn resume(&mut self) -> Result<(), xous::Error> { - send_message(self.conn, - Message::new_scalar(Opcode::ResumeStream.to_usize().unwrap(), 0, 0, 0, 0) - ).map(|_| ()) + send_message(self.conn, Message::new_scalar(Opcode::ResumeStream.to_usize().unwrap(), 0, 0, 0, 0)) + .map(|_| ()) } + pub fn pause(&mut self) -> Result<(), xous::Error> { - send_message(self.conn, - Message::new_scalar(Opcode::PauseStream.to_usize().unwrap(), 0, 0, 0, 0) - ).map(|_| ()) + send_message(self.conn, Message::new_scalar(Opcode::PauseStream.to_usize().unwrap(), 0, 0, 0, 0)) + .map(|_| ()) } + pub fn abort(&mut self) -> Result<(), xous::Error> { - send_message(self.conn, - Message::new_scalar(Opcode::AbortStream.to_usize().unwrap(), 0, 0, 0, 0) - ).map(|_| ()) + send_message(self.conn, Message::new_scalar(Opcode::AbortStream.to_usize().unwrap(), 0, 0, 0, 0)) + .map(|_| ()) } /// gain goes from 0dB down to -80dB pub fn set_speaker_volume(&self, op: VolumeOps, gain: Option) -> Result<(), xous::Error> { let code = if let Some(g) = gain { - if g > 0.0 { - 0 as usize - } else { - (-g * 10.0) as usize - } + if g > 0.0 { 0 as usize } else { (-g * 10.0) as usize } } else { 800 // -80.0 dB => mute }; - send_message(self.conn, - Message::new_scalar(Opcode::SetSpeakerVolume.to_usize().unwrap(), + send_message( + self.conn, + Message::new_scalar( + Opcode::SetSpeakerVolume.to_usize().unwrap(), op.to_usize().unwrap(), code, // gain as -dB * 10 as usize 0, - 0 - ) - ).map(|_| ()) + 0, + ), + ) + .map(|_| ()) } + /// gain goes from 0dB down to -80dB pub fn set_headphone_volume(&self, op: VolumeOps, gain: Option) -> Result<(), xous::Error> { let code = if let Some(g) = gain { - if g > 0.0 { - 0 as usize - } else { - (-g * 10.0) as usize - } + if g > 0.0 { 0 as usize } else { (-g * 10.0) as usize } } else { 800 // -80.0 dB => mute }; - send_message(self.conn, - Message::new_scalar(Opcode::SetHeadphoneVolume.to_usize().unwrap(), + send_message( + self.conn, + Message::new_scalar( + Opcode::SetHeadphoneVolume.to_usize().unwrap(), op.to_usize().unwrap(), code, // gain as -dB * 10 as usize 0, - 0 - ) - ).map(|_| ()) + 0, + ), + ) + .map(|_| ()) } + pub fn is_running(&self) -> Result { - match send_message(self.conn, - Message::new_blocking_scalar(Opcode::IsLive.to_usize().unwrap(), 0, 0, 0, 0) + match send_message( + self.conn, + Message::new_blocking_scalar(Opcode::IsLive.to_usize().unwrap(), 0, 0, 0, 0), ) { Ok(xous::Result::Scalar1(is_live)) => { if is_live != 0 { @@ -139,12 +140,14 @@ impl Codec { Ok(false) } } - _ => Err(xous::Error::InternalError) + _ => Err(xous::Error::InternalError), } } + pub fn poll_headphone_state(&self) -> Result { - match send_message(self.conn, - Message::new_blocking_scalar(Opcode::GetHeadphoneCode.to_usize().unwrap(), 0, 0, 0, 0) + match send_message( + self.conn, + Message::new_blocking_scalar(Opcode::GetHeadphoneCode.to_usize().unwrap(), 0, 0, 0, 0), ) { Ok(xous::Result::Scalar1(code)) => { let retcode: Option = FromPrimitive::from_usize(code); @@ -153,7 +156,7 @@ impl Codec { None => Err(xous::Error::InternalError), } } - _ => Err(xous::Error::InternalError) + _ => Err(xous::Error::InternalError), } } } @@ -162,14 +165,18 @@ use core::sync::atomic::{AtomicU32, Ordering}; static REFCOUNT: AtomicU32 = AtomicU32::new(0); impl Drop for Codec { fn drop(&mut self) { - // de-allocate myself. It's unsafe because we are responsible to make sure nobody else is using the connection. + // de-allocate myself. It's unsafe because we are responsible to make sure nobody else is using the + // connection. if REFCOUNT.fetch_sub(1, Ordering::Relaxed) == 1 { - unsafe{xous::disconnect(self.conn).unwrap();} + unsafe { + xous::disconnect(self.conn).unwrap(); + } } } } -/// handles callback messages that indicate an audio frame has been used up, in the library user's process space. +/// handles callback messages that indicate an audio frame has been used up, in the library user's process +/// space. fn frame_cb_server(sid0: usize, sid1: usize, sid2: usize, sid3: usize) { let sid = xous::SID::from_u32(sid0 as u32, sid1 as u32, sid2 as u32, sid3 as u32); loop { @@ -177,9 +184,11 @@ fn frame_cb_server(sid0: usize, sid1: usize, sid2: usize, sid3: usize) { match FromPrimitive::from_usize(msg.body.id()) { Some(EventCallback::Event) => xous::msg_scalar_unpack!(msg, cid, id, free_play, avail_rec, { // directly pass the scalar message onto the CID with the ID memorized in the original hook - send_message(cid as u32, - Message::new_scalar(id, free_play, avail_rec, 0, AUDIO_CB_ROUTING_ID) - ).unwrap(); + send_message( + cid as u32, + Message::new_scalar(id, free_play, avail_rec, 0, AUDIO_CB_ROUTING_ID), + ) + .unwrap(); }), Some(EventCallback::Drop) => { break; // this exits the loop and kills the thread diff --git a/services/codec/src/main.rs b/services/codec/src/main.rs index b69e49bc2..20140eb3e 100644 --- a/services/codec/src/main.rs +++ b/services/codec/src/main.rs @@ -3,15 +3,12 @@ mod api; mod backend; -use backend::Codec; - -use num_traits::{ToPrimitive, FromPrimitive}; -use xous_ipc::Buffer; -use xous::{CID, msg_scalar_unpack}; - -use log::info; - use api::*; +use backend::Codec; +use log::info; +use num_traits::{FromPrimitive, ToPrimitive}; +use xous::{msg_scalar_unpack, CID}; +use xous_ipc::Buffer; #[derive(Copy, Clone, Debug)] struct ScalarCallback { @@ -20,14 +17,9 @@ struct ScalarCallback { cb_to_client_id: u32, } -fn main () -> ! { +fn main() -> ! { let stack_size = 256 * 1024; - std::thread::Builder::new() - .stack_size(stack_size) - .spawn(wrapped_main) - .unwrap() - .join() - .unwrap() + std::thread::Builder::new().stack_size(stack_size).spawn(wrapped_main).unwrap().join().unwrap() } fn wrapped_main() -> ! { @@ -48,7 +40,13 @@ fn wrapped_main() -> ! { // register a suspend/resume listener let sr_cid = xous::connect(codec_sid).expect("couldn't create suspend callback connection"); - let mut susres = susres::Susres::new(Some(susres::SuspendOrder::Normal), &xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object"); + let mut susres = susres::Susres::new( + Some(susres::SuspendOrder::Normal), + &xns, + api::Opcode::SuspendResume as u32, + sr_cid, + ) + .expect("couldn't create suspend/resume object"); /* let trng = trng::Trng::new(&xns).unwrap(); let mut noise: [u32; codec::FIFO_DEPTH] = [0; codec::FIFO_DEPTH]; @@ -107,11 +105,7 @@ fn wrapped_main() -> ! { } }), Some(api::Opcode::IsLive) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, { - let ret = if codec.is_live() { - 1 - } else { - 0 - }; + let ret = if codec.is_live() { 1 } else { 0 }; xous::return_scalar(msg.sender, ret).expect("couldn't return if codec is live"); }), Some(api::Opcode::FreeFrames) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, { @@ -120,7 +114,8 @@ fn wrapped_main() -> ! { xous::return_scalar2(msg.sender, play_free, rec_avail).expect("couldn't return FreeFrames"); }), Some(api::Opcode::SwapFrames) => { - let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let mut buffer = + unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; let mut framering = buffer.to_original::().unwrap(); loop { @@ -163,7 +158,7 @@ fn wrapped_main() -> ! { } buffer.replace(framering).unwrap(); - }, + } Some(api::Opcode::AudioStreamSubscribe) => { let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let hookdata = buffer.to_original::().unwrap(); @@ -179,25 +174,25 @@ fn wrapped_main() -> ! { match FromPrimitive::from_usize(op) { Some(VolumeOps::Set) => { speaker_analog_gain_db = -(gain_code as f32) / 10.0; - }, + } Some(VolumeOps::Mute) => { speaker_analog_gain_db = -80.0; - }, + } Some(VolumeOps::RestoreDefault) => { speaker_analog_gain_db = -6.0; - }, + } Some(VolumeOps::UpOne) => { speaker_analog_gain_db += 3.0; if speaker_analog_gain_db >= 0.0 { speaker_analog_gain_db = 0.0; } - }, + } Some(VolumeOps::DownOne) => { speaker_analog_gain_db -= 3.0; if speaker_analog_gain_db <= -80.0 { speaker_analog_gain_db = -80.0; } - }, + } _ => log::error!("got speaker volume primitive that we don't recognize, ignoring!"), }; codec.set_speaker_gain_db(speaker_analog_gain_db); @@ -206,25 +201,25 @@ fn wrapped_main() -> ! { match FromPrimitive::from_usize(op) { Some(VolumeOps::Set) => { headphone_analog_gain_db = -(gain_code as f32) / 10.0; - }, + } Some(VolumeOps::Mute) => { headphone_analog_gain_db = -80.0; - }, + } Some(VolumeOps::RestoreDefault) => { headphone_analog_gain_db = -6.0; - }, + } Some(VolumeOps::UpOne) => { headphone_analog_gain_db += 3.0; if headphone_analog_gain_db >= 0.0 { headphone_analog_gain_db = 0.0; } - }, + } Some(VolumeOps::DownOne) => { headphone_analog_gain_db -= 3.0; if headphone_analog_gain_db <= -80.0 { headphone_analog_gain_db = -80.0; } - }, + } _ => log::error!("got speaker volume primitive that we don't recognize, ignoring!"), }; codec.set_headphone_gain_db(headphone_analog_gain_db, headphone_analog_gain_db); @@ -236,7 +231,8 @@ fn wrapped_main() -> ! { log::warn!("Headphone detection polled, but detection is not enabled in hardware!"); } log::debug!("headset code: 0x{:x}", hp_code); - let code = if hp_code == 0xff { // kind of a hack, we could also check codec power state + let code = if hp_code == 0xff { + // kind of a hack, we could also check codec power state HeadphoneState::CodecOff } else { match (hp_code >> 5) & 0x3 { @@ -254,7 +250,7 @@ fn wrapped_main() -> ! { }), None => { log::error!("couldn't convert opcode"); - break + break; } } } @@ -267,7 +263,6 @@ fn wrapped_main() -> ! { xous::terminate_process(0) } - fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option; 32]) { let (s0, s1, s2, s3) = hookdata.sid; let sid = xous::SID::from_u32(s0, s1, s2, s3); @@ -292,10 +287,14 @@ fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option; 32]) { fn unhook(cb_conns: &mut [Option; 32]) { for entry in cb_conns.iter_mut() { if let Some(scb) = entry { - xous::send_message(scb.server_to_cb_cid, - xous::Message::new_blocking_scalar(EventCallback::Drop.to_usize().unwrap(), 0, 0, 0, 0) - ).unwrap(); - unsafe{xous::disconnect(scb.server_to_cb_cid).unwrap();} + xous::send_message( + scb.server_to_cb_cid, + xous::Message::new_blocking_scalar(EventCallback::Drop.to_usize().unwrap(), 0, 0, 0, 0), + ) + .unwrap(); + unsafe { + xous::disconnect(scb.server_to_cb_cid).unwrap(); + } } *entry = None; } @@ -303,11 +302,19 @@ fn unhook(cb_conns: &mut [Option; 32]) { fn send_event(cb_conns: &[Option; 32], free_play: usize, avail_rec: usize) { for entry in cb_conns.iter() { if let Some(scb) = entry { - // note that the "which" argument is only used for GPIO events, to indicate which pin had the event - xous::send_message(scb.server_to_cb_cid, - xous::Message::new_scalar(EventCallback::Event.to_usize().unwrap(), - scb.cb_to_client_cid as usize, scb.cb_to_client_id as usize, free_play, avail_rec) - ).unwrap(); + // note that the "which" argument is only used for GPIO events, to indicate which pin had the + // event + xous::send_message( + scb.server_to_cb_cid, + xous::Message::new_scalar( + EventCallback::Event.to_usize().unwrap(), + scb.cb_to_client_cid as usize, + scb.cb_to_client_id as usize, + free_play, + avail_rec, + ), + ) + .unwrap(); }; } }