| //! Driver for VirtIO Sound devices. |
| |
| #[cfg(test)] |
| mod fake; |
| |
| use super::common::Feature; |
| use crate::{ |
| queue::{owning::OwningQueue, VirtQueue}, |
| transport::Transport, |
| volatile::{volread, ReadOnly}, |
| Error, Hal, Result, PAGE_SIZE, |
| }; |
| use alloc::{boxed::Box, collections::BTreeMap, vec, vec::Vec}; |
| use bitflags::bitflags; |
| use core::{ |
| array, |
| fmt::{self, Debug, Display, Formatter}, |
| hint::spin_loop, |
| mem::size_of, |
| ops::RangeInclusive, |
| }; |
| use enumn::N; |
| use log::{error, info, warn}; |
| use zerocopy::{AsBytes, FromBytes, FromZeroes}; |
| |
| /// Audio driver based on virtio v1.2. |
| /// |
| /// Supports synchronous blocking and asynchronous non-blocking audio playback. |
| /// |
| /// Currently, only audio playback functionality has been implemented. |
| pub struct VirtIOSound<H: Hal, T: Transport> { |
| transport: T, |
| |
| control_queue: VirtQueue<H, { QUEUE_SIZE as usize }>, |
| event_queue: OwningQueue<H, { QUEUE_SIZE as usize }, { size_of::<VirtIOSndEvent>() }>, |
| tx_queue: VirtQueue<H, { QUEUE_SIZE as usize }>, |
| rx_queue: VirtQueue<H, { QUEUE_SIZE as usize }>, |
| |
| negotiated_features: Feature, |
| |
| jacks: u32, |
| streams: u32, |
| chmaps: u32, |
| |
| pcm_infos: Option<Vec<VirtIOSndPcmInfo>>, |
| jack_infos: Option<Vec<VirtIOSndJackInfo>>, |
| chmap_infos: Option<Vec<VirtIOSndChmapInfo>>, |
| |
| // pcm params |
| pcm_parameters: Vec<PcmParameters>, |
| |
| queue_buf_send: Box<[u8]>, |
| queue_buf_recv: Box<[u8]>, |
| |
| set_up: bool, |
| |
| token_rsp: BTreeMap<u16, Box<VirtIOSndPcmStatus>>, // includes pcm_xfer response msg |
| |
| pcm_states: Vec<PCMState>, |
| |
| token_buf: BTreeMap<u16, Vec<u8>>, // store token and its input buf |
| } |
| |
| impl<H: Hal, T: Transport> VirtIOSound<H, T> { |
| /// Create a new VirtIO-Sound driver. |
| pub fn new(mut transport: T) -> Result<Self> { |
| let negotiated_features = transport.begin_init(SUPPORTED_FEATURES); |
| info!( |
| "[sound device] negotiated_features: {:?}", |
| negotiated_features |
| ); |
| |
| let control_queue = VirtQueue::new( |
| &mut transport, |
| CONTROL_QUEUE_IDX, |
| negotiated_features.contains(Feature::RING_INDIRECT_DESC), |
| negotiated_features.contains(Feature::RING_EVENT_IDX), |
| )?; |
| let event_queue = OwningQueue::new(VirtQueue::new( |
| &mut transport, |
| EVENT_QUEUE_IDX, |
| negotiated_features.contains(Feature::RING_INDIRECT_DESC), |
| negotiated_features.contains(Feature::RING_EVENT_IDX), |
| )?)?; |
| let tx_queue = VirtQueue::new( |
| &mut transport, |
| TX_QUEUE_IDX, |
| negotiated_features.contains(Feature::RING_INDIRECT_DESC), |
| negotiated_features.contains(Feature::RING_EVENT_IDX), |
| )?; |
| let rx_queue = VirtQueue::new( |
| &mut transport, |
| RX_QUEUE_IDX, |
| negotiated_features.contains(Feature::RING_INDIRECT_DESC), |
| negotiated_features.contains(Feature::RING_EVENT_IDX), |
| )?; |
| |
| // read configuration space |
| let config_ptr = transport.config_space::<VirtIOSoundConfig>()?; |
| // SAFETY: config_ptr is a valid pointer to the device configuration space. |
| let (jacks, streams, chmaps) = unsafe { |
| ( |
| volread!(config_ptr, jacks), |
| volread!(config_ptr, streams), |
| volread!(config_ptr, chmaps), |
| ) |
| }; |
| info!( |
| "[sound device] config: jacks: {}, streams: {}, chmaps: {}", |
| jacks, streams, chmaps |
| ); |
| |
| let queue_buf_send = FromZeroes::new_box_slice_zeroed(PAGE_SIZE); |
| let queue_buf_recv = FromZeroes::new_box_slice_zeroed(PAGE_SIZE); |
| |
| // set pcm params to default |
| let mut pcm_parameters = vec![]; |
| for _ in 0..streams { |
| pcm_parameters.push(PcmParameters::default()); |
| } |
| |
| transport.finish_init(); |
| |
| if event_queue.should_notify() { |
| transport.notify(EVENT_QUEUE_IDX); |
| } |
| |
| Ok(VirtIOSound { |
| transport, |
| control_queue, |
| event_queue, |
| tx_queue, |
| rx_queue, |
| negotiated_features, |
| jacks, |
| streams, |
| chmaps, |
| pcm_infos: None, |
| jack_infos: None, |
| chmap_infos: None, |
| queue_buf_send, |
| queue_buf_recv, |
| pcm_parameters, |
| set_up: false, |
| token_rsp: BTreeMap::new(), |
| pcm_states: vec![], |
| token_buf: BTreeMap::new(), |
| }) |
| } |
| |
| /// Total jack num. |
| pub fn jacks(&self) -> u32 { |
| self.jacks |
| } |
| |
| /// Total stream num. |
| pub fn streams(&self) -> u32 { |
| self.streams |
| } |
| |
| /// Total chmap num. |
| pub fn chmaps(&self) -> u32 { |
| self.chmaps |
| } |
| |
| /// Acknowledge interrupt. |
| pub fn ack_interrupt(&mut self) -> bool { |
| self.transport.ack_interrupt() |
| } |
| |
| fn request<Req: AsBytes>(&mut self, req: Req) -> Result<VirtIOSndHdr> { |
| self.control_queue.add_notify_wait_pop( |
| &[req.as_bytes()], |
| &mut [self.queue_buf_recv.as_bytes_mut()], |
| &mut self.transport, |
| )?; |
| Ok(VirtIOSndHdr::read_from_prefix(&self.queue_buf_recv).unwrap()) |
| } |
| |
| /// Set up the driver, initate pcm_infos and jacks_infos |
| fn set_up(&mut self) -> Result<()> { |
| // init jack info |
| if let Ok(jack_infos) = self.jack_info(0, self.jacks) { |
| for jack_info in &jack_infos { |
| info!("[sound device] jack_info: {}", jack_info); |
| } |
| self.jack_infos = Some(jack_infos); |
| } else { |
| self.jack_infos = Some(vec![]); |
| warn!("[sound device] Error getting jack infos"); |
| } |
| |
| // init pcm info |
| let pcm_infos = self.pcm_info(0, self.streams)?; |
| for pcm_info in &pcm_infos { |
| info!("[sound device] pcm_info: {}", pcm_info); |
| } |
| self.pcm_infos = Some(pcm_infos); |
| |
| // init chmap info |
| if let Ok(chmap_infos) = self.chmap_info(0, self.chmaps) { |
| for chmap_info in &chmap_infos { |
| info!("[sound device] chmap_info: {}", chmap_info); |
| } |
| self.chmap_infos = Some(chmap_infos); |
| } else { |
| self.chmap_infos = Some(vec![]); |
| warn!("[sound device] Error getting chmap infos"); |
| } |
| |
| // set pcm state to default |
| for _ in 0..self.streams { |
| self.pcm_states.push(PCMState::default()); |
| } |
| Ok(()) |
| } |
| |
| /// Enables interrupts from the device. |
| pub fn enable_interrupts(&mut self, enable: bool) { |
| self.event_queue.set_dev_notify(enable); |
| } |
| |
| /// Query information about the available jacks. |
| fn jack_info(&mut self, jack_start_id: u32, jack_count: u32) -> Result<Vec<VirtIOSndJackInfo>> { |
| if jack_start_id + jack_count > self.jacks { |
| error!("jack_start_id + jack_count > jacks! There are not enough jacks to be queried!"); |
| return Err(Error::IoError); |
| } |
| let hdr = self.request(VirtIOSndQueryInfo { |
| hdr: ItemInformationRequestType::RJackInfo.into(), |
| start_id: jack_start_id, |
| count: jack_count, |
| size: size_of::<VirtIOSndJackInfo>() as u32, |
| })?; |
| if hdr != RequestStatusCode::Ok.into() { |
| return Err(Error::IoError); |
| } |
| // read struct VirtIOSndJackInfo |
| let mut jack_infos = vec![]; |
| for i in 0..jack_count as usize { |
| const HDR_SIZE: usize = size_of::<VirtIOSndHdr>(); |
| const JACK_INFO_SIZE: usize = size_of::<VirtIOSndJackInfo>(); |
| let start_byte_idx = HDR_SIZE + i * JACK_INFO_SIZE; |
| let end_byte_idx = HDR_SIZE + (i + 1) * JACK_INFO_SIZE; |
| let jack_info = |
| VirtIOSndJackInfo::read_from(&self.queue_buf_recv[start_byte_idx..end_byte_idx]) |
| .unwrap(); |
| jack_infos.push(jack_info) |
| } |
| Ok(jack_infos) |
| } |
| |
| /// Query information about the available streams. |
| fn pcm_info( |
| &mut self, |
| stream_start_id: u32, |
| stream_count: u32, |
| ) -> Result<Vec<VirtIOSndPcmInfo>> { |
| if stream_start_id + stream_count > self.streams { |
| error!("stream_start_id + stream_count > streams! There are not enough streams to be queried!"); |
| return Err(Error::IoError); |
| } |
| let request_hdr = VirtIOSndHdr::from(ItemInformationRequestType::RPcmInfo); |
| let hdr = self.request(VirtIOSndQueryInfo { |
| hdr: request_hdr, |
| start_id: stream_start_id, |
| count: stream_count, |
| size: size_of::<VirtIOSndPcmInfo>() as u32, |
| })?; |
| if hdr != RequestStatusCode::Ok.into() { |
| return Err(Error::IoError); |
| } |
| // read struct VirtIOSndPcmInfo |
| let mut pcm_infos = vec![]; |
| for i in 0..stream_count as usize { |
| const HDR_SIZE: usize = size_of::<VirtIOSndHdr>(); |
| const PCM_INFO_SIZE: usize = size_of::<VirtIOSndPcmInfo>(); |
| let start_byte_idx = HDR_SIZE + i * PCM_INFO_SIZE; |
| let end_byte_idx = HDR_SIZE + (i + 1) * PCM_INFO_SIZE; |
| let pcm_info = |
| VirtIOSndPcmInfo::read_from(&self.queue_buf_recv[start_byte_idx..end_byte_idx]) |
| .unwrap(); |
| pcm_infos.push(pcm_info); |
| } |
| Ok(pcm_infos) |
| } |
| |
| /// Query information about the available chmaps. |
| fn chmap_info( |
| &mut self, |
| chmaps_start_id: u32, |
| chmaps_count: u32, |
| ) -> Result<Vec<VirtIOSndChmapInfo>> { |
| if chmaps_start_id + chmaps_count > self.chmaps { |
| error!("chmaps_start_id + chmaps_count > self.chmaps"); |
| return Err(Error::IoError); |
| } |
| let hdr = self.request(VirtIOSndQueryInfo { |
| hdr: ItemInformationRequestType::RChmapInfo.into(), |
| start_id: chmaps_start_id, |
| count: chmaps_count, |
| size: size_of::<VirtIOSndChmapInfo>() as u32, |
| })?; |
| if hdr != RequestStatusCode::Ok.into() { |
| return Err(Error::IoError); |
| } |
| let mut chmap_infos = vec![]; |
| for i in 0..chmaps_count as usize { |
| const OFFSET: usize = size_of::<VirtIOSndHdr>(); |
| let start_byte = OFFSET + i * size_of::<VirtIOSndChmapInfo>(); |
| let end_byte = OFFSET + (i + 1) * size_of::<VirtIOSndChmapInfo>(); |
| let chmap_info = |
| VirtIOSndChmapInfo::read_from(&self.queue_buf_recv[start_byte..end_byte]).unwrap(); |
| chmap_infos.push(chmap_info); |
| } |
| Ok(chmap_infos) |
| } |
| |
| /// If the VIRTIO_SND_JACK_F_REMAP feature bit is set in the jack information, then the driver can send a |
| /// control request to change the association and/or sequence number for the specified jack ID. |
| /// # Arguments |
| /// |
| /// * `jack_id` - A u32 int which is in the range of [0, jacks) |
| pub fn jack_remap(&mut self, jack_id: u32, association: u32, sequence: u32) -> Result { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if self.jacks == 0 { |
| error!("[sound device] There is no available jacks!"); |
| return Err(Error::InvalidParam); |
| } |
| if jack_id >= self.jacks { |
| error!("jack_id >= self.jacks! Make sure jack_id is in the range of [0, jacks - 1)!"); |
| return Err(Error::InvalidParam); |
| } |
| |
| let jack_features = JackFeatures::from_bits_retain( |
| self.jack_infos |
| .as_ref() |
| .unwrap() |
| .get(jack_id as usize) |
| .unwrap() |
| .features, |
| ); |
| if !jack_features.contains(JackFeatures::REMAP) { |
| error!("The jack selected does not support VIRTIO_SND_JACK_F_REMAP!"); |
| return Err(Error::Unsupported); |
| } |
| let hdr = self.request(VirtIOSndJackRemap { |
| hdr: VirtIOSndJackHdr { |
| hdr: CommandCode::RJackRemap.into(), |
| jack_id, |
| }, |
| association, |
| sequence, |
| })?; |
| if hdr == RequestStatusCode::Ok.into() { |
| Ok(()) |
| } else { |
| Err(Error::Unsupported) |
| } |
| } |
| |
| /// Set selected stream parameters for the specified stream ID. |
| pub fn pcm_set_params( |
| &mut self, |
| stream_id: u32, |
| buffer_bytes: u32, |
| period_bytes: u32, |
| features: PcmFeatures, |
| channels: u8, |
| format: PcmFormat, |
| rate: PcmRate, |
| ) -> Result { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if period_bytes == 0 || period_bytes > buffer_bytes || buffer_bytes % period_bytes != 0 { |
| return Err(Error::InvalidParam); |
| } |
| let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmSetParams); |
| let rsp = self.request(VirtIOSndPcmSetParams { |
| hdr: VirtIOSndPcmHdr { |
| hdr: request_hdr, |
| stream_id, |
| }, |
| buffer_bytes, |
| period_bytes, |
| features: features.bits(), |
| channels, |
| format: format.into(), |
| rate: rate.into(), |
| _padding: 0, |
| })?; |
| // rsp is just a header, so it can be compared with VirtIOSndHdr |
| if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) { |
| self.pcm_parameters[stream_id as usize] = PcmParameters { |
| setup: true, |
| buffer_bytes, |
| period_bytes, |
| features, |
| channels, |
| format, |
| rate, |
| }; |
| Ok(()) |
| } else { |
| Err(Error::IoError) |
| } |
| } |
| |
| /// Prepare a stream with specified stream ID. |
| pub fn pcm_prepare(&mut self, stream_id: u32) -> Result { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmPrepare); |
| let rsp = self.request(VirtIOSndPcmHdr { |
| hdr: request_hdr, |
| stream_id, |
| })?; |
| // rsp is just a header, so it can be compared with VirtIOSndHdr |
| if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) { |
| Ok(()) |
| } else { |
| Err(Error::IoError) |
| } |
| } |
| |
| /// Release a stream with specified stream ID. |
| pub fn pcm_release(&mut self, stream_id: u32) -> Result { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmRelease); |
| let rsp = self.request(VirtIOSndPcmHdr { |
| hdr: request_hdr, |
| stream_id, |
| })?; |
| // rsp is just a header, so it can be compared with VirtIOSndHdr |
| if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) { |
| Ok(()) |
| } else { |
| Err(Error::IoError) |
| } |
| } |
| |
| /// Start a stream with specified stream ID. |
| pub fn pcm_start(&mut self, stream_id: u32) -> Result { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmStart); |
| let rsp = self.request(VirtIOSndPcmHdr { |
| hdr: request_hdr, |
| stream_id, |
| })?; |
| // rsp is just a header, so it can be compared with VirtIOSndHdr |
| if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) { |
| Ok(()) |
| } else { |
| Err(Error::IoError) |
| } |
| } |
| |
| /// Stop a stream with specified stream ID. |
| pub fn pcm_stop(&mut self, stream_id: u32) -> Result { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmStop); |
| let rsp = self.request(VirtIOSndPcmHdr { |
| hdr: request_hdr, |
| stream_id, |
| })?; |
| // rsp is just a header, so it can be compared with VirtIOSndHdr |
| if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) { |
| Ok(()) |
| } else { |
| Err(Error::IoError) |
| } |
| } |
| |
| /// Transfer PCM frame to device, based on the stream type(OUTPUT/INPUT). |
| /// |
| /// Currently supports only output stream. |
| /// |
| /// This is a blocking method that will not return until the audio playback is complete. |
| pub fn pcm_xfer(&mut self, stream_id: u32, frames: &[u8]) -> Result { |
| const U32_SIZE: usize = size_of::<u32>(); |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if !self.pcm_parameters[stream_id as usize].setup { |
| warn!("Please set parameters for a stream before using it!"); |
| return Err(Error::IoError); |
| } |
| |
| let stream_id_bytes = stream_id.to_le_bytes(); |
| let period_size = self.pcm_parameters[stream_id as usize].period_bytes as usize; |
| |
| let mut remaining_buffers = frames.chunks(period_size); |
| let mut buffers: [Option<&[u8]>; QUEUE_SIZE as usize] = [None; QUEUE_SIZE as usize]; |
| let mut statuses: [VirtIOSndPcmStatus; QUEUE_SIZE as usize] = |
| array::from_fn(|_| Default::default()); |
| let mut tokens = [0; QUEUE_SIZE as usize]; |
| // The next element of `statuses` and `tokens` to use for adding to the queue. |
| let mut head = 0; |
| // The next element of `status` and `tokens` to use for popping the queue. |
| let mut tail = 0; |
| |
| loop { |
| // Add as buffers to the TX queue if possible. 3 descriptors are required for the 2 |
| // input buffers and 1 output buffer. |
| if self.tx_queue.available_desc() >= 3 { |
| if let Some(buffer) = remaining_buffers.next() { |
| tokens[head] = unsafe { |
| self.tx_queue.add( |
| &[&stream_id_bytes, buffer], |
| &mut [statuses[head].as_bytes_mut()], |
| )? |
| }; |
| if self.tx_queue.should_notify() { |
| self.transport.notify(TX_QUEUE_IDX); |
| } |
| buffers[head] = Some(buffer); |
| head += 1; |
| if head >= usize::from(QUEUE_SIZE) { |
| head = 0; |
| } |
| } else if head == tail { |
| break; |
| } |
| } |
| if self.tx_queue.can_pop() { |
| unsafe { |
| self.tx_queue.pop_used( |
| tokens[tail], |
| &[&stream_id_bytes, buffers[tail].unwrap()], |
| &mut [statuses[tail].as_bytes_mut()], |
| )?; |
| } |
| if statuses[tail].status != CommandCode::SOk.into() { |
| return Err(Error::IoError); |
| } |
| tail += 1; |
| if tail >= usize::from(QUEUE_SIZE) { |
| tail = 0; |
| } |
| } |
| spin_loop(); |
| } |
| |
| Ok(()) |
| } |
| |
| /// Transfer PCM frame to device, based on the stream type(OUTPUT/INPUT). |
| /// |
| /// Currently supports only output stream. |
| /// |
| /// This is a non-blocking method that returns a token. |
| /// |
| /// The length of the `frames` must be equal to the buffer size set for the stream corresponding to the `stream_id`. |
| pub fn pcm_xfer_nb(&mut self, stream_id: u32, frames: &[u8]) -> Result<u16> { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if !self.pcm_parameters[stream_id as usize].setup { |
| warn!("Please set parameters for a stream before using it!"); |
| return Err(Error::IoError); |
| } |
| const U32_SIZE: usize = size_of::<u32>(); |
| let period_size: usize = self.pcm_parameters[stream_id as usize].period_bytes as usize; |
| assert_eq!(period_size, frames.len()); |
| let mut buf = vec![0; U32_SIZE + period_size]; |
| buf[..U32_SIZE].copy_from_slice(&stream_id.to_le_bytes()); |
| buf[U32_SIZE..U32_SIZE + period_size].copy_from_slice(frames); |
| let mut rsp = VirtIOSndPcmStatus::new_box_zeroed(); |
| let token = unsafe { self.tx_queue.add(&[&buf], &mut [rsp.as_bytes_mut()])? }; |
| if self.tx_queue.should_notify() { |
| self.transport.notify(TX_QUEUE_IDX); |
| } |
| self.token_buf.insert(token, buf); |
| self.token_rsp.insert(token, rsp); |
| Ok(token) |
| } |
| |
| /// The PCM frame transmission corresponding to the given token has been completed. |
| pub fn pcm_xfer_ok(&mut self, token: u16) -> Result { |
| assert!(self.token_buf.contains_key(&token)); |
| assert!(self.token_rsp.contains_key(&token)); |
| unsafe { |
| self.tx_queue.pop_used( |
| token, |
| &[&self.token_buf[&token]], |
| &mut [self.token_rsp.get_mut(&token).unwrap().as_bytes_mut()], |
| )?; |
| } |
| |
| self.token_buf.remove(&token); |
| self.token_rsp.remove(&token); |
| Ok(()) |
| } |
| |
| /// Get all output streams. |
| pub fn output_streams(&mut self) -> Result<Vec<u32>> { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| Ok(self |
| .pcm_infos |
| .as_ref() |
| .unwrap() |
| .iter() |
| .enumerate() |
| .filter(|(_, info)| info.direction == VIRTIO_SND_D_OUTPUT) |
| .map(|(idx, _)| idx as u32) |
| .collect()) |
| } |
| |
| /// Get all input streams. |
| pub fn input_streams(&mut self) -> Result<Vec<u32>> { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| Ok(self |
| .pcm_infos |
| .as_ref() |
| .unwrap() |
| .iter() |
| .enumerate() |
| .filter(|(_, info)| info.direction == VIRTIO_SND_D_INPUT) |
| .map(|(idx, _)| idx as u32) |
| .collect()) |
| } |
| |
| /// Get the rates that a stream supports. |
| pub fn rates_supported(&mut self, stream_id: u32) -> Result<PcmRates> { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 { |
| return Err(Error::InvalidParam); |
| } |
| Ok(PcmRates::from_bits_retain( |
| self.pcm_infos.as_ref().unwrap()[stream_id as usize].rates, |
| )) |
| } |
| |
| /// Get the formats that a stream supports. |
| pub fn formats_supported(&mut self, stream_id: u32) -> Result<PcmFormats> { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 { |
| return Err(Error::InvalidParam); |
| } |
| Ok(PcmFormats::from_bits_retain( |
| self.pcm_infos.as_ref().unwrap()[stream_id as usize].formats, |
| )) |
| } |
| |
| /// Get channel range that a stream supports. |
| pub fn channel_range_supported(&mut self, stream_id: u32) -> Result<RangeInclusive<u8>> { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 { |
| return Err(Error::InvalidParam); |
| } |
| let pcm_info = &self.pcm_infos.as_ref().unwrap()[stream_id as usize]; |
| Ok(pcm_info.channels_min..=pcm_info.channels_max) |
| } |
| |
| /// Get features that a stream supports. |
| pub fn features_supported(&mut self, stream_id: u32) -> Result<PcmFeatures> { |
| if !self.set_up { |
| self.set_up()?; |
| self.set_up = true; |
| } |
| if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 { |
| return Err(Error::InvalidParam); |
| } |
| let pcm_info = &self.pcm_infos.as_ref().unwrap()[stream_id as usize]; |
| Ok(PcmFeatures::from_bits_retain(pcm_info.features)) |
| } |
| |
| /// Get the latest notification. |
| pub fn latest_notification(&mut self) -> Result<Option<Notification>> { |
| // If the device has written notifications to the event_queue, |
| // then the oldest notification should be at the front of the queue. |
| self.event_queue.poll(&mut self.transport, |buffer| { |
| if let Some(event) = VirtIOSndEvent::read_from(buffer) { |
| Ok(Some(Notification { |
| notification_type: NotificationType::n(event.hdr.command_code) |
| .ok_or(Error::IoError)?, |
| data: event.data, |
| })) |
| } else { |
| Ok(None) |
| } |
| }) |
| } |
| } |
| |
| /// The status of the PCM stream. |
| #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)] |
| enum PCMState { |
| #[default] |
| SetParams, |
| Prepare, |
| Release, |
| Start, |
| Stop, |
| } |
| |
| const QUEUE_SIZE: u16 = 32; |
| const CONTROL_QUEUE_IDX: u16 = 0; |
| const EVENT_QUEUE_IDX: u16 = 1; |
| const TX_QUEUE_IDX: u16 = 2; |
| const RX_QUEUE_IDX: u16 = 3; |
| |
| const SUPPORTED_FEATURES: Feature = Feature::RING_INDIRECT_DESC.union(Feature::RING_EVENT_IDX); |
| |
| bitflags! { |
| #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] |
| #[repr(transparent)] |
| struct JackFeatures: u32 { |
| /// Jack remapping support. |
| const REMAP = 1 << 0; |
| } |
| } |
| |
| bitflags! { |
| /// Supported PCM stream features. |
| #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] |
| #[repr(transparent)] |
| pub struct PcmFeatures: u32 { |
| /// Supports sharing a host memory with a guest. |
| const SHMEM_HOST = 1 << 0; |
| /// Supports sharing a guest memory with a host. |
| const SHMEM_GUEST = 1 << 1; |
| /// Supports polling mode for message-based transport. |
| const MSG_POLLING = 1 << 2; |
| /// Supports elapsed period notifications for shared memory transport. |
| const EVT_SHMEM_PERIODS = 1 << 3; |
| /// Supports underrun/overrun notifications. |
| const EVT_XRUNS = 1 << 4; |
| } |
| } |
| |
| bitflags! { |
| /// Supported PCM sample formats. |
| #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] |
| #[repr(transparent)] |
| pub struct PcmFormats: u64 { |
| /// IMA ADPCM format. |
| const IMA_ADPCM = 1 << 0; |
| /// Mu-law format. |
| const MU_LAW = 1 << 1; |
| /// A-law format. |
| const A_LAW = 1 << 2; |
| /// Signed 8-bit format. |
| const S8 = 1 << 3; |
| /// Unsigned 8-bit format. |
| const U8 = 1 << 4; |
| /// Signed 16-bit format. |
| const S16 = 1 << 5; |
| /// Unsigned 16-bit format. |
| const U16 = 1 << 6; |
| /// Signed 18.3-bit format. |
| const S18_3 = 1 << 7; |
| /// Unsigned 18.3-bit format. |
| const U18_3 = 1 << 8; |
| /// Signed 20.3-bit format. |
| const S20_3 = 1 << 9; |
| /// Unsigned 20.3-bit format. |
| const U20_3 = 1 << 10; |
| /// Signed 24.3-bit format. |
| const S24_3 = 1 << 11; |
| /// Unsigned 24.3-bit format. |
| const U24_3 = 1 << 12; |
| /// Signed 20-bit format. |
| const S20 = 1 << 13; |
| /// Unsigned 20-bit format. |
| const U20 = 1 << 14; |
| /// Signed 24-bit format. |
| const S24 = 1 << 15; |
| /// Unsigned 24-bit format. |
| const U24 = 1 << 16; |
| /// Signed 32-bit format. |
| const S32 = 1 << 17; |
| /// Unsigned 32-bit format. |
| const U32 = 1 << 18; |
| /// 32-bit floating-point format. |
| const FLOAT = 1 << 19; |
| /// 64-bit floating-point format. |
| const FLOAT64 = 1 << 20; |
| /// DSD unsigned 8-bit format. |
| const DSD_U8 = 1 << 21; |
| /// DSD unsigned 16-bit format. |
| const DSD_U16 = 1 << 22; |
| /// DSD unsigned 32-bit format. |
| const DSD_U32 = 1 << 23; |
| /// IEC958 subframe format. |
| const IEC958_SUBFRAME = 1 << 24; |
| } |
| } |
| |
| /// A single PCM sample format. |
| #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] |
| #[repr(u8)] |
| pub enum PcmFormat { |
| /// IMA ADPCM format. |
| #[default] |
| ImaAdpcm = 0, |
| /// Mu-law format. |
| MuLaw = 1, |
| /// A-law format. |
| ALaw = 2, |
| /// Signed 8-bit format. |
| S8 = 3, |
| /// Unsigned 8-bit format. |
| U8 = 4, |
| /// Signed 16-bit format. |
| S16 = 5, |
| /// Unsigned 16-bit format. |
| U16 = 6, |
| /// Signed 18.3-bit format. |
| S18_3 = 7, |
| /// Unsigned 18.3-bit format. |
| U18_3 = 8, |
| /// Signed 20.3-bit format. |
| S20_3 = 9, |
| /// Unsigned 20.3-bit format. |
| U20_3 = 10, |
| /// Signed 24.3-bit format. |
| S24_3 = 11, |
| /// Unsigned 24.3-bit format. |
| U24_3 = 12, |
| /// Signed 20-bit format. |
| S20 = 13, |
| /// Unsigned 20-bit format. |
| U20 = 14, |
| /// Signed 24-bit format. |
| S24 = 15, |
| /// Unsigned 24-bit format. |
| U24 = 16, |
| /// Signed 32-bit format. |
| S32 = 17, |
| /// Unsigned 32-bit format. |
| U32 = 18, |
| /// 32-bit floating-point format. |
| FLOAT = 19, |
| /// 64-bit floating-point format. |
| FLOAT64 = 20, |
| /// DSD unsigned 8-bit format. |
| DsdU8 = 21, |
| /// DSD unsigned 16-bit format. |
| DsdU16 = 22, |
| /// DSD unsigned 32-bit format. |
| DsdU32 = 23, |
| /// IEC958 subframe format. |
| Iec958Subframe = 24, |
| } |
| |
| impl From<PcmFormat> for PcmFormats { |
| fn from(format: PcmFormat) -> Self { |
| match format { |
| PcmFormat::ImaAdpcm => PcmFormats::IMA_ADPCM, |
| PcmFormat::MuLaw => PcmFormats::MU_LAW, |
| PcmFormat::ALaw => PcmFormats::A_LAW, |
| PcmFormat::S8 => PcmFormats::S8, |
| PcmFormat::U8 => PcmFormats::U8, |
| PcmFormat::S16 => PcmFormats::S16, |
| PcmFormat::U16 => PcmFormats::U16, |
| PcmFormat::S18_3 => PcmFormats::S18_3, |
| PcmFormat::U18_3 => PcmFormats::U18_3, |
| PcmFormat::S20_3 => PcmFormats::S20_3, |
| PcmFormat::U20_3 => PcmFormats::U20_3, |
| PcmFormat::S24_3 => PcmFormats::S24_3, |
| PcmFormat::U24_3 => PcmFormats::U24_3, |
| PcmFormat::S20 => PcmFormats::S20, |
| PcmFormat::U20 => PcmFormats::U20, |
| PcmFormat::S24 => PcmFormats::S24, |
| PcmFormat::U24 => PcmFormats::U24, |
| PcmFormat::S32 => PcmFormats::S32, |
| PcmFormat::U32 => PcmFormats::U32, |
| PcmFormat::FLOAT => PcmFormats::FLOAT, |
| PcmFormat::FLOAT64 => PcmFormats::FLOAT64, |
| PcmFormat::DsdU8 => PcmFormats::DSD_U8, |
| PcmFormat::DsdU16 => PcmFormats::DSD_U16, |
| PcmFormat::DsdU32 => PcmFormats::DSD_U32, |
| PcmFormat::Iec958Subframe => PcmFormats::IEC958_SUBFRAME, |
| } |
| } |
| } |
| |
| impl From<PcmFormat> for u8 { |
| fn from(format: PcmFormat) -> u8 { |
| format as _ |
| } |
| } |
| |
| bitflags! { |
| /// Supported PCM frame rates. |
| #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] |
| #[repr(transparent)] |
| pub struct PcmRates: u64 { |
| /// 5512 Hz PCM rate. |
| const RATE_5512 = 1 << 0; |
| /// 8000 Hz PCM rate. |
| const RATE_8000 = 1 << 1; |
| /// 11025 Hz PCM rate. |
| const RATE_11025 = 1 << 2; |
| /// 16000 Hz PCM rate. |
| const RATE_16000 = 1 << 3; |
| /// 22050 Hz PCM rate. |
| const RATE_22050 = 1 << 4; |
| /// 32000 Hz PCM rate. |
| const RATE_32000 = 1 << 5; |
| /// 44100 Hz PCM rate. |
| const RATE_44100 = 1 << 6; |
| /// 48000 Hz PCM rate. |
| const RATE_48000 = 1 << 7; |
| /// 64000 Hz PCM rate. |
| const RATE_64000 = 1 << 8; |
| /// 88200 Hz PCM rate. |
| const RATE_88200 = 1 << 9; |
| /// 96000 Hz PCM rate. |
| const RATE_96000 = 1 << 10; |
| /// 176400 Hz PCM rate. |
| const RATE_176400 = 1 << 11; |
| /// 192000 Hz PCM rate. |
| const RATE_192000 = 1 << 12; |
| /// 384000 Hz PCM rate. |
| const RATE_384000 = 1 << 13; |
| } |
| } |
| |
| /// A PCM frame rate. |
| #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] |
| #[repr(u8)] |
| pub enum PcmRate { |
| /// 5512 Hz PCM rate. |
| #[default] |
| Rate5512 = 0, |
| /// 8000 Hz PCM rate. |
| Rate8000 = 1, |
| /// 11025 Hz PCM rate. |
| Rate11025 = 2, |
| /// 16000 Hz PCM rate. |
| Rate16000 = 3, |
| /// 22050 Hz PCM rate. |
| Rate22050 = 4, |
| /// 32000 Hz PCM rate. |
| Rate32000 = 5, |
| /// 44100 Hz PCM rate. |
| Rate44100 = 6, |
| /// 48000 Hz PCM rate. |
| Rate48000 = 7, |
| /// 64000 Hz PCM rate. |
| Rate64000 = 8, |
| /// 88200 Hz PCM rate. |
| Rate88200 = 9, |
| /// 96000 Hz PCM rate. |
| Rate96000 = 10, |
| /// 176400 Hz PCM rate. |
| Rate176400 = 11, |
| /// 192000 Hz PCM rate. |
| Rate192000 = 12, |
| /// 384000 Hz PCM rate. |
| Rate384000 = 13, |
| } |
| |
| impl From<PcmRate> for PcmRates { |
| fn from(rate: PcmRate) -> Self { |
| match rate { |
| PcmRate::Rate5512 => Self::RATE_5512, |
| PcmRate::Rate8000 => Self::RATE_8000, |
| PcmRate::Rate11025 => Self::RATE_11025, |
| PcmRate::Rate16000 => Self::RATE_16000, |
| PcmRate::Rate22050 => Self::RATE_22050, |
| PcmRate::Rate32000 => Self::RATE_32000, |
| PcmRate::Rate44100 => Self::RATE_44100, |
| PcmRate::Rate48000 => Self::RATE_48000, |
| PcmRate::Rate64000 => Self::RATE_64000, |
| PcmRate::Rate88200 => Self::RATE_88200, |
| PcmRate::Rate96000 => Self::RATE_96000, |
| PcmRate::Rate176400 => Self::RATE_176400, |
| PcmRate::Rate192000 => Self::RATE_192000, |
| PcmRate::Rate384000 => Self::RATE_384000, |
| } |
| } |
| } |
| |
| impl From<PcmRate> for u8 { |
| fn from(rate: PcmRate) -> Self { |
| rate as _ |
| } |
| } |
| |
| #[repr(C)] |
| struct VirtIOSoundConfig { |
| jacks: ReadOnly<u32>, |
| streams: ReadOnly<u32>, |
| chmaps: ReadOnly<u32>, |
| } |
| |
| /// In virtIO v1.2, this enum should be called "Code". |
| /// |
| /// To avoid ambiguity in its meaning, I use the term "CommandCode" here. |
| #[repr(u32)] |
| #[derive(Copy, Clone, Debug, Eq, N, PartialEq)] |
| enum CommandCode { |
| /* jack control request types */ |
| RJackInfo = 1, |
| RJackRemap, |
| |
| /* PCM control request types */ |
| RPcmInfo = 0x0100, |
| RPcmSetParams, |
| RPcmPrepare, |
| RPcmRelease, |
| RPcmStart, |
| RPcmStop, |
| |
| /* channel map control request types */ |
| RChmapInfo = 0x0200, |
| |
| /* jack event types */ |
| EvtJackConnected = 0x1000, |
| EvtJackDisconnected, |
| |
| /* PCM event types */ |
| EvtPcmPeriodElapsed = 0x1100, |
| EvtPcmXrun, |
| |
| /* common status codes */ |
| /// success |
| SOk = 0x8000, |
| /// a control message is malformed or contains invalid parameters |
| SBadMsg, |
| /// requested operation or parameters are not supported |
| SNotSupp, |
| /// an I/O error occurred |
| SIoErr, |
| } |
| |
| impl From<CommandCode> for u32 { |
| fn from(code: CommandCode) -> u32 { |
| code as u32 |
| } |
| } |
| |
| /// Enum representing the types of item information requests. |
| #[repr(u32)] |
| #[derive(Clone, Copy, Debug, PartialEq, Eq)] |
| pub enum ItemInformationRequestType { |
| /// Represents a jack information request. |
| RJackInfo = 1, |
| /// Represents a PCM information request. |
| RPcmInfo = 0x0100, |
| /// Represents a channel map information request. |
| RChmapInfo = 0x0200, |
| } |
| |
| impl From<ItemInformationRequestType> for VirtIOSndHdr { |
| fn from(value: ItemInformationRequestType) -> Self { |
| VirtIOSndHdr { |
| command_code: value.into(), |
| } |
| } |
| } |
| |
| impl From<ItemInformationRequestType> for u32 { |
| fn from(request_type: ItemInformationRequestType) -> u32 { |
| request_type as _ |
| } |
| } |
| |
| #[derive(Copy, Clone, Eq, PartialEq)] |
| #[repr(u32)] |
| enum RequestStatusCode { |
| /* common status codes */ |
| Ok = 0x8000, |
| BadMsg, |
| NotSupp, |
| IoErr, |
| } |
| |
| impl From<RequestStatusCode> for VirtIOSndHdr { |
| fn from(value: RequestStatusCode) -> Self { |
| VirtIOSndHdr { |
| command_code: value as _, |
| } |
| } |
| } |
| |
| /// A common header |
| #[repr(C)] |
| #[derive(AsBytes, Clone, Debug, Eq, FromBytes, FromZeroes, PartialEq)] |
| struct VirtIOSndHdr { |
| command_code: u32, |
| } |
| |
| impl From<CommandCode> for VirtIOSndHdr { |
| fn from(value: CommandCode) -> Self { |
| VirtIOSndHdr { |
| command_code: value.into(), |
| } |
| } |
| } |
| |
| #[repr(C)] |
| #[derive(FromBytes, FromZeroes)] |
| /// An event notification |
| struct VirtIOSndEvent { |
| hdr: VirtIOSndHdr, |
| data: u32, |
| } |
| |
| /// The notification type. |
| #[repr(u32)] |
| #[derive(Debug, Copy, Clone, PartialEq, Eq)] |
| pub enum NotificationType { |
| /// An external device has been connected to the jack. |
| JackConnected = 0x1000, |
| /// An external device has been disconnected from the jack. |
| JackDisconnected, |
| /// A hardware buffer period has elapsed, the period size is controlled using the `period_bytes` field. |
| PcmPeriodElapsed = 0x1100, |
| /// An underflow for the output stream or an overflow for the inputstream has occurred. |
| PcmXrun, |
| } |
| |
| impl NotificationType { |
| /// Converts the given value to a variant of this enum, if any matches. |
| fn n(value: u32) -> Option<Self> { |
| match value { |
| 0x1100 => Some(Self::PcmPeriodElapsed), |
| 0x1101 => Some(Self::PcmXrun), |
| 0x1000 => Some(Self::JackConnected), |
| 0x1001 => Some(Self::JackDisconnected), |
| _ => None, |
| } |
| } |
| } |
| |
| /// Notification from sound device. |
| #[derive(Clone, Debug, Eq, PartialEq)] |
| pub struct Notification { |
| notification_type: NotificationType, |
| data: u32, |
| } |
| |
| impl Notification { |
| /// Get the resource index. |
| pub fn data(&self) -> u32 { |
| self.data |
| } |
| |
| /// Get the notification type. |
| pub fn notification_type(&self) -> NotificationType { |
| self.notification_type |
| } |
| } |
| |
| const VIRTIO_SND_D_OUTPUT: u8 = 0; |
| const VIRTIO_SND_D_INPUT: u8 = 1; |
| |
| #[repr(C)] |
| #[derive(AsBytes, Debug, FromBytes, FromZeroes)] |
| struct VirtIOSndQueryInfo { |
| /// specifies a particular item request type (VIRTIO_SND_R_*_INFO) |
| hdr: VirtIOSndHdr, |
| /// specifies the starting identifier for the item |
| /// (the range of available identifiers is limited |
| /// by the total number of particular items |
| /// that is indicated in the device configuration space) |
| start_id: u32, |
| /// specifies the number of items for which information is requested |
| /// (the total number of particular items is indicated |
| /// in the device configuration space). |
| count: u32, |
| /// specifies the size of the structure containing information for one item |
| /// (used for backward compatibility) |
| size: u32, |
| } |
| |
| #[repr(C)] |
| #[derive(AsBytes, Debug, FromBytes, FromZeroes)] |
| struct VirtIOSndQueryInfoRsp { |
| hdr: VirtIOSndHdr, |
| info: VirtIOSndInfo, |
| } |
| |
| /// Field `hda_fn_nid` indicates a function group node identifier. |
| #[repr(C)] |
| #[derive(AsBytes, Clone, Debug, Eq, FromBytes, FromZeroes, PartialEq)] |
| pub struct VirtIOSndInfo { |
| hda_fn_nid: u32, |
| } |
| |
| #[repr(C)] |
| #[derive(AsBytes, Clone, Debug, FromBytes, FromZeroes)] |
| struct VirtIOSndJackHdr { |
| hdr: VirtIOSndHdr, |
| /// specifies a jack identifier from 0 to jacks - 1 |
| jack_id: u32, |
| } |
| |
| /// Jack infomation. |
| #[repr(C)] |
| #[derive(AsBytes, Clone, Eq, FromBytes, FromZeroes, PartialEq)] |
| pub struct VirtIOSndJackInfo { |
| hdr: VirtIOSndInfo, |
| features: u32, |
| /// indicates a pin default configuration value |
| hda_reg_defconf: u32, |
| /// indicates a pin capabilities value |
| hda_reg_caps: u32, |
| /// indicates the current jack connection status (1 - connected, 0 - disconnected) |
| connected: u8, |
| |
| _padding: [u8; 7], |
| } |
| |
| impl Debug for VirtIOSndJackInfo { |
| fn fmt(&self, f: &mut Formatter) -> fmt::Result { |
| f.debug_struct("VirtIOSndJackInfo") |
| .field("hdr", &self.hdr) |
| .field("features", &JackFeatures::from_bits_retain(self.features)) |
| .field("hda_reg_defconf", &self.hda_reg_defconf) |
| .field("hda_reg_caps", &self.hda_reg_caps) |
| .field("connected", &self.connected) |
| .field("_padding", &self._padding) |
| .finish() |
| } |
| } |
| |
| impl Display for VirtIOSndJackInfo { |
| fn fmt(&self, f: &mut Formatter) -> fmt::Result { |
| let connected_status = if self.connected == 1 { |
| "CONNECTED" |
| } else { |
| "DISCONNECTED" |
| }; |
| write!( |
| f, |
| "features: {:?}, hda_reg_defconf: {}, hda_reg_caps: {}, connected: {}", |
| JackFeatures::from_bits_retain(self.features), |
| self.hda_reg_defconf, |
| self.hda_reg_caps, |
| connected_status |
| ) |
| } |
| } |
| |
| #[repr(C)] |
| #[derive(AsBytes, FromBytes, FromZeroes)] |
| struct VirtIOSndJackInfoRsp { |
| hdr: VirtIOSndHdr, |
| body: VirtIOSndJackInfo, |
| } |
| |
| #[repr(C)] |
| #[derive(AsBytes, FromBytes, FromZeroes)] |
| struct VirtIOSndJackRemap { |
| hdr: VirtIOSndJackHdr, |
| association: u32, |
| sequence: u32, |
| } |
| |
| #[repr(C)] |
| #[derive(AsBytes, Debug, Eq, FromBytes, FromZeroes, PartialEq)] |
| struct VirtIOSndPcmHdr { |
| /// specifies request type (VIRTIO_SND_R_PCM_*) |
| hdr: VirtIOSndHdr, |
| /// specifies a PCM stream identifier from 0 to streams - 1 |
| stream_id: u32, |
| } |
| |
| #[derive(Copy, Clone, Debug, Eq, PartialEq)] |
| enum PcmStreamFeatures { |
| ShmemHost = 0, |
| ShmemGuest, |
| MsgPolling, |
| EvtShmemPeriods, |
| EvtXruns, |
| } |
| |
| impl From<PcmStreamFeatures> for u32 { |
| fn from(value: PcmStreamFeatures) -> Self { |
| value as _ |
| } |
| } |
| |
| #[derive(Copy, Clone, Debug, Eq, PartialEq)] |
| #[repr(u64)] |
| enum PcmSampleFormat { |
| /* analog formats (width / physical width) */ |
| ImaAdpcm = 0, /* 4 / 4 bits */ |
| MuLaw, /* 8 / 8 bits */ |
| ALaw, /* 8 / 8 bits */ |
| S8, /* 8 / 8 bits */ |
| U8, /* 8 / 8 bits */ |
| S16, /* 16 / 16 bits */ |
| U16, /* 16 / 16 bits */ |
| S18_3, /* 18 / 24 bits */ |
| U18_3, /* 18 / 24 bits */ |
| S20_3, /* 20 / 24 bits */ |
| U20_3, /* 20 / 24 bits */ |
| S24_3, /* 24 / 24 bits */ |
| U24_3, /* 24 / 24 bits */ |
| S20, /* 20 / 32 bits */ |
| U20, /* 20 / 32 bits */ |
| S24, /* 24 / 32 bits */ |
| U24, /* 24 / 32 bits */ |
| S32, /* 32 / 32 bits */ |
| U32, /* 32 / 32 bits */ |
| Float, /* 32 / 32 bits */ |
| Float64, /* 64 / 64 bits */ |
| /* digital formats (width / physical width) */ |
| DsdU8, /* 8 / 8 bits */ |
| DsdU16, /* 16 / 16 bits */ |
| DsdU32, /* 32 / 32 bits */ |
| Iec958Subframe, /* 32 / 32 bits */ |
| } |
| |
| impl From<PcmSampleFormat> for u64 { |
| fn from(value: PcmSampleFormat) -> Self { |
| value as _ |
| } |
| } |
| |
| /// PCM information. |
| #[repr(C)] |
| #[derive(AsBytes, Clone, Eq, FromBytes, FromZeroes, PartialEq)] |
| pub struct VirtIOSndPcmInfo { |
| hdr: VirtIOSndInfo, |
| features: u32, /* 1 << VIRTIO_SND_PCM_F_XXX */ |
| formats: u64, /* 1 << VIRTIO_SND_PCM_FMT_XXX */ |
| rates: u64, /* 1 << VIRTIO_SND_PCM_RATE_XXX */ |
| /// indicates the direction of data flow (VIRTIO_SND_D_*) |
| direction: u8, |
| /// indicates a minimum number of supported channels |
| channels_min: u8, |
| /// indicates a maximum number of supported channels |
| channels_max: u8, |
| _padding: [u8; 5], |
| } |
| |
| impl Debug for VirtIOSndPcmInfo { |
| fn fmt(&self, f: &mut Formatter) -> fmt::Result { |
| f.debug_struct("VirtIOSndPcmInfo") |
| .field("hdr", &self.hdr) |
| .field("features", &PcmFeatures::from_bits_retain(self.features)) |
| .field("formats", &PcmFormats::from_bits_retain(self.formats)) |
| .field("rates", &PcmRates::from_bits_retain(self.rates)) |
| .field("direction", &self.direction) |
| .field("channels_min", &self.channels_min) |
| .field("channels_max", &self.channels_max) |
| .field("_padding", &self._padding) |
| .finish() |
| } |
| } |
| |
| impl Display for VirtIOSndPcmInfo { |
| fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { |
| let direction = if self.direction == VIRTIO_SND_D_INPUT { |
| "INPUT" |
| } else { |
| "OUTPUT" |
| }; |
| write!( |
| f, |
| "features: {:?}, rates: {:?}, formats: {:?}, direction: {}", |
| PcmFeatures::from_bits_retain(self.features), |
| PcmRates::from_bits_retain(self.rates), |
| PcmFormats::from_bits_retain(self.formats), |
| direction |
| ) |
| } |
| } |
| |
| #[derive(Clone, Debug, Default, Eq, PartialEq)] |
| struct PcmParameters { |
| setup: bool, |
| buffer_bytes: u32, |
| period_bytes: u32, |
| features: PcmFeatures, |
| channels: u8, |
| format: PcmFormat, |
| rate: PcmRate, |
| } |
| |
| #[repr(C)] |
| #[derive(AsBytes, Debug, Eq, FromBytes, FromZeroes, PartialEq)] |
| struct VirtIOSndPcmSetParams { |
| hdr: VirtIOSndPcmHdr, /* .code = VIRTIO_SND_R_PCM_SET_PARAMS */ |
| buffer_bytes: u32, |
| period_bytes: u32, |
| features: u32, /* 1 << VIRTIO_SND_PCM_F_XXX */ |
| channels: u8, |
| format: u8, |
| rate: u8, |
| |
| _padding: u8, |
| } |
| |
| /// An I/O header |
| #[repr(C)] |
| #[derive(AsBytes, FromBytes, FromZeroes)] |
| struct VirtIOSndPcmXfer { |
| stream_id: u32, |
| } |
| |
| /// An I/O status |
| #[repr(C)] |
| #[derive(AsBytes, Default, FromBytes, FromZeroes)] |
| struct VirtIOSndPcmStatus { |
| status: u32, |
| latency_bytes: u32, |
| } |
| |
| #[derive(Copy, Clone, Debug, Eq, N, PartialEq)] |
| #[repr(u8)] |
| enum ChannelPosition { |
| /// undefined |
| None = 0, |
| /// silent |
| Na, |
| /// mono stream |
| Mono, |
| /// front left |
| Fl, |
| /// front right |
| Fr, |
| /// rear left |
| Rl, |
| /// rear right |
| Rr, |
| /// front center |
| Fc, |
| /// low frequency (LFE) |
| Lfe, |
| /// side left |
| Sl, |
| /// side right |
| Sr, |
| /// rear center |
| Rc, |
| /// front left center |
| Flc, |
| /// front right center |
| Frc, |
| /// rear left center |
| Rlc, |
| /// rear right center |
| Rrc, |
| /// front left wide |
| Flw, |
| /// front right wide |
| Frw, |
| /// front left high |
| Flh, |
| /// front center high |
| Fch, |
| /// front right high |
| Frh, |
| /// top center |
| Tc, |
| /// top front left |
| Tfl, |
| /// top front right |
| Tfr, |
| /// top front center |
| Tfc, |
| /// top rear left |
| Trl, |
| /// top rear right |
| Trr, |
| /// top rear center |
| Trc, |
| /// top front left center |
| Tflc, |
| /// top front right center |
| Tfrc, |
| /// top side left |
| Tsl, |
| /// top side right |
| Tsr, |
| /// left LFE |
| Llfe, |
| /// right LFE |
| Rlfe, |
| /// bottom center |
| Bc, |
| /// bottom left center |
| Blc, |
| /// bottom right center |
| Brc, |
| } |
| |
| /// maximum possible number of channels |
| const VIRTIO_SND_CHMAP_MAX_SIZE: usize = 18; |
| |
| #[repr(C)] |
| #[derive(AsBytes, Clone, Debug, FromBytes, FromZeroes)] |
| struct VirtIOSndChmapInfo { |
| hdr: VirtIOSndInfo, |
| direction: u8, |
| channels: u8, |
| positions: [u8; VIRTIO_SND_CHMAP_MAX_SIZE], |
| } |
| |
| impl Display for VirtIOSndChmapInfo { |
| fn fmt(&self, f: &mut Formatter) -> fmt::Result { |
| let direction = if self.direction == VIRTIO_SND_D_INPUT { |
| "INPUT" |
| } else { |
| "OUTPUT" |
| }; |
| write!( |
| f, |
| "direction: {}, channels: {}, postions: [", |
| direction, self.channels |
| )?; |
| for i in 0..usize::from(self.channels) { |
| if i != 0 { |
| write!(f, ", ")?; |
| } |
| if let Some(position) = ChannelPosition::n(self.positions[i]) { |
| write!(f, "{:?}", position)?; |
| } else { |
| write!(f, "{}", self.positions[i])?; |
| } |
| } |
| write!(f, "]")?; |
| Ok(()) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use crate::{ |
| hal::fake::FakeHal, |
| transport::{ |
| fake::{FakeTransport, QueueStatus, State}, |
| DeviceType, |
| }, |
| volatile::ReadOnly, |
| }; |
| use alloc::{sync::Arc, vec}; |
| use core::ptr::NonNull; |
| use fake::FakeSoundDevice; |
| use std::sync::Mutex; |
| |
| #[test] |
| fn config() { |
| let mut config_space = VirtIOSoundConfig { |
| jacks: ReadOnly::new(3), |
| streams: ReadOnly::new(4), |
| chmaps: ReadOnly::new(2), |
| }; |
| let state = Arc::new(Mutex::new(State { |
| queues: vec![ |
| QueueStatus::default(), |
| QueueStatus::default(), |
| QueueStatus::default(), |
| QueueStatus::default(), |
| ], |
| ..Default::default() |
| })); |
| let transport = FakeTransport { |
| device_type: DeviceType::Sound, |
| max_queue_size: 32, |
| device_features: 0, |
| config_space: NonNull::from(&mut config_space), |
| state: state.clone(), |
| }; |
| let sound = |
| VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap(); |
| assert_eq!(sound.jacks(), 3); |
| assert_eq!(sound.streams(), 4); |
| assert_eq!(sound.chmaps(), 2); |
| } |
| |
| #[test] |
| fn empty_info() { |
| let (fake, transport) = FakeSoundDevice::new(vec![], vec![], vec![]); |
| let mut sound = |
| VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap(); |
| let handle = fake.spawn(); |
| |
| assert_eq!(sound.jacks(), 0); |
| assert_eq!(sound.streams(), 0); |
| assert_eq!(sound.chmaps(), 0); |
| assert_eq!(sound.output_streams().unwrap(), vec![]); |
| assert_eq!(sound.input_streams().unwrap(), vec![]); |
| |
| fake.terminate(); |
| handle.join().unwrap(); |
| } |
| |
| #[test] |
| fn stream_info() { |
| let (fake, transport) = FakeSoundDevice::new( |
| vec![VirtIOSndJackInfo { |
| hdr: VirtIOSndInfo { hda_fn_nid: 0 }, |
| features: 0, |
| hda_reg_defconf: 0, |
| hda_reg_caps: 0, |
| connected: 0, |
| _padding: Default::default(), |
| }], |
| vec![ |
| VirtIOSndPcmInfo { |
| hdr: VirtIOSndInfo { hda_fn_nid: 0 }, |
| features: 0, |
| formats: (PcmFormats::U8 | PcmFormats::U32).bits(), |
| rates: (PcmRates::RATE_44100 | PcmRates::RATE_32000).bits(), |
| direction: VIRTIO_SND_D_OUTPUT, |
| channels_min: 1, |
| channels_max: 2, |
| _padding: Default::default(), |
| }, |
| VirtIOSndPcmInfo { |
| hdr: VirtIOSndInfo { hda_fn_nid: 0 }, |
| features: 0, |
| formats: 0, |
| rates: 0, |
| direction: VIRTIO_SND_D_INPUT, |
| channels_min: 0, |
| channels_max: 0, |
| _padding: Default::default(), |
| }, |
| ], |
| vec![VirtIOSndChmapInfo { |
| hdr: VirtIOSndInfo { hda_fn_nid: 0 }, |
| direction: 0, |
| channels: 0, |
| positions: [0; 18], |
| }], |
| ); |
| let mut sound = |
| VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap(); |
| let handle = fake.spawn(); |
| |
| assert_eq!(sound.output_streams().unwrap(), vec![0]); |
| assert_eq!( |
| sound.rates_supported(0).unwrap(), |
| PcmRates::RATE_44100 | PcmRates::RATE_32000 |
| ); |
| assert_eq!( |
| sound.formats_supported(0).unwrap(), |
| PcmFormats::U8 | PcmFormats::U32 |
| ); |
| assert_eq!(sound.channel_range_supported(0).unwrap(), 1..=2); |
| assert_eq!(sound.features_supported(0).unwrap(), PcmFeatures::empty()); |
| |
| assert_eq!(sound.input_streams().unwrap(), vec![1]); |
| assert_eq!(sound.rates_supported(1).unwrap(), PcmRates::empty()); |
| assert_eq!(sound.formats_supported(1).unwrap(), PcmFormats::empty()); |
| assert_eq!(sound.channel_range_supported(1).unwrap(), 0..=0); |
| assert_eq!(sound.features_supported(1).unwrap(), PcmFeatures::empty()); |
| |
| fake.terminate(); |
| handle.join().unwrap(); |
| } |
| |
| #[test] |
| fn play() { |
| let (fake, transport) = FakeSoundDevice::new( |
| vec![], |
| vec![VirtIOSndPcmInfo { |
| hdr: VirtIOSndInfo { hda_fn_nid: 0 }, |
| features: 0, |
| formats: (PcmFormats::U8 | PcmFormats::U32).bits(), |
| rates: (PcmRates::RATE_44100 | PcmRates::RATE_32000).bits(), |
| direction: VIRTIO_SND_D_OUTPUT, |
| channels_min: 1, |
| channels_max: 2, |
| _padding: Default::default(), |
| }], |
| vec![], |
| ); |
| let mut sound = |
| VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap(); |
| let handle = fake.spawn(); |
| |
| assert_eq!(sound.output_streams().unwrap(), vec![0]); |
| assert_eq!(sound.input_streams().unwrap(), vec![]); |
| |
| sound |
| .pcm_set_params( |
| 0, |
| 100, |
| 100, |
| PcmFeatures::empty(), |
| 1, |
| PcmFormat::U8, |
| PcmRate::Rate8000, |
| ) |
| .unwrap(); |
| assert_eq!( |
| fake.params.lock().unwrap()[0], |
| Some(VirtIOSndPcmSetParams { |
| hdr: VirtIOSndPcmHdr { |
| hdr: VirtIOSndHdr { |
| command_code: CommandCode::RPcmSetParams.into(), |
| }, |
| stream_id: 0, |
| }, |
| buffer_bytes: 100, |
| period_bytes: 100, |
| features: 0, |
| channels: 1, |
| format: PcmFormat::U8.into(), |
| rate: PcmRate::Rate8000.into(), |
| _padding: Default::default(), |
| }) |
| ); |
| |
| sound.pcm_prepare(0).unwrap(); |
| sound.pcm_start(0).unwrap(); |
| |
| let mut expected_sound = vec![]; |
| |
| // Playing an empty set of frames should be a no-op. |
| println!("Playing empty"); |
| sound.pcm_xfer(0, &[]).unwrap(); |
| assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound); |
| |
| // Send one buffer worth. |
| println!("Playing 100"); |
| sound.pcm_xfer(0, &[42; 100]).unwrap(); |
| expected_sound.extend([42; 100]); |
| assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound); |
| |
| // Send two buffers worth. |
| println!("Playing 200"); |
| sound.pcm_xfer(0, &[66; 200]).unwrap(); |
| expected_sound.extend([66; 200]); |
| assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound); |
| |
| // Send half a buffer worth. |
| println!("Playing 50"); |
| sound.pcm_xfer(0, &[55; 50]).unwrap(); |
| expected_sound.extend([55; 50]); |
| assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound); |
| |
| // Send enough that the queue will fill up. |
| println!("Playing 5000"); |
| sound.pcm_xfer(0, &[12; 5000]).unwrap(); |
| expected_sound.extend([12; 5000]); |
| assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound); |
| |
| sound.pcm_stop(0).unwrap(); |
| sound.pcm_release(0).unwrap(); |
| |
| fake.terminate(); |
| handle.join().unwrap(); |
| } |
| } |
