use super::{DeviceConfig, DeviceProperties, DmaHostBuffer, DramInfo, PoppedResponse, Transport};
use crate::error::{Error, Result};
use crate::ffi::ops;
use crate::ioctl;
use std::cell::Cell;
use std::os::fd::{AsRawFd, FromRawFd, OwnedFd, RawFd};
use std::path::Path;
use std::time::Duration;
pub struct IoctlTransport {
fd: OwnedFd,
max_msg: Cell<Option<usize>>,
}
impl IoctlTransport {
pub fn open(index: u32) -> Result<Self> {
Self::open_path(format!("/dev/et{index}_ops"))
}
pub fn open_path<P: AsRef<Path>>(path: P) -> Result<Self> {
use std::os::unix::ffi::OsStrExt;
let mut bytes = path.as_ref().as_os_str().as_bytes().to_vec();
bytes.push(0);
let raw = unsafe { libc::open(bytes.as_ptr().cast(), libc::O_RDWR | libc::O_CLOEXEC) };
if raw < 0 {
return Err(Error::last_os("open(/dev/etN_ops)"));
}
let fd = unsafe { OwnedFd::from_raw_fd(raw) };
Ok(Self {
fd,
max_msg: Cell::new(None),
})
}
pub fn from_owned_fd(fd: OwnedFd) -> Self {
Self {
fd,
max_msg: Cell::new(None),
}
}
fn raw(&self) -> RawFd {
self.fd.as_raw_fd()
}
fn cached_max_msg(&self) -> Result<usize> {
if let Some(v) = self.max_msg.get() {
return Ok(v);
}
let v = self.sq_max_msg_size()? as usize;
self.max_msg.set(Some(v));
Ok(v)
}
fn poll(&self, events: libc::c_short, timeout: Duration) -> Result<bool> {
let mut pfd = libc::pollfd {
fd: self.raw(),
events,
revents: 0,
};
let millis = timeout.as_millis().min(libc::c_int::MAX as u128) as libc::c_int;
let rc = unsafe { libc::poll(&mut pfd, 1, millis) };
if rc < 0 {
return Err(Error::last_os("poll"));
}
Ok(rc > 0 && (pfd.revents & events) != 0)
}
}
impl Transport for IoctlTransport {
fn dram_info(&self) -> Result<DramInfo> {
let info: ops::dram_info =
ioctl::read_scalar(self.raw(), ioctl::GET_USER_DRAM_INFO, "GET_USER_DRAM_INFO")?;
Ok(DramInfo {
base: info.base,
size: info.size,
dma_max_elem_size: info.dma_max_elem_size,
dma_max_elem_count: info.dma_max_elem_count,
dma_alignment: info.align_in_bits,
})
}
fn device_config(&self) -> Result<DeviceConfig> {
let cfg: ops::dev_config = ioctl::read_scalar(
self.raw(),
ioctl::GET_DEVICE_CONFIGURATION,
"GET_DEVICE_CONFIGURATION",
)?;
Ok(DeviceConfig {
shire_mask: u64::from(cfg.cm_shire_mask),
cache_line: u32::from(cfg.cache_line_size),
})
}
fn device_properties(&self) -> Result<DeviceProperties> {
let cfg: ops::dev_config = ioctl::read_scalar(
self.raw(),
ioctl::GET_DEVICE_CONFIGURATION,
"GET_DEVICE_CONFIGURATION",
)?;
Ok(DeviceProperties {
total_l3_size: cfg.total_l3_size,
total_l2_size: cfg.total_l2_size,
total_scp_size: cfg.total_scp_size,
ddr_bandwidth: cfg.ddr_bandwidth,
minion_boot_freq: cfg.minion_boot_freq,
shire_mask: cfg.cm_shire_mask,
form_factor: cfg.form_factor,
tdp: cfg.tdp,
cache_line_size: cfg.cache_line_size,
num_l2_cache_banks: cfg.num_l2_cache_banks,
sync_min_shire_id: cfg.sync_min_shire_id,
arch_rev: cfg.arch_rev,
devnum: cfg.devnum,
})
}
fn fw_update(&self, image: &[u8]) -> Result<()> {
let mut desc = ops::fw_update_desc {
ubuf: image.as_ptr() as *mut libc::c_void,
size: image.len() as u64,
};
unsafe {
ioctl::ioctl(
self.raw(),
ioctl::FW_UPDATE,
(&raw mut desc).cast(),
"FW_UPDATE",
)?;
}
Ok(())
}
fn sq_count(&self) -> Result<u16> {
ioctl::read_scalar::<u16>(self.raw(), ioctl::GET_SQ_COUNT, "GET_SQ_COUNT")
}
fn sq_max_msg_size(&self) -> Result<u16> {
ioctl::read_scalar::<u16>(
self.raw(),
ioctl::GET_SQ_MAX_MSG_SIZE,
"GET_SQ_MAX_MSG_SIZE",
)
}
fn push_sq(&self, sq_index: u16, cmd: &[u8], flags: u8) -> Result<bool> {
let mut desc: ops::cmd_desc = unsafe { std::mem::zeroed() };
desc.cmd = cmd.as_ptr() as *mut libc::c_void;
desc.size = cmd.len() as u16;
desc.sq_index = sq_index;
desc.flags = flags;
let rc = unsafe {
libc::ioctl(
self.raw(),
ioctl::PUSH_SQ,
(&raw mut desc).cast::<libc::c_void>(),
)
};
if rc < 0 {
let err = std::io::Error::last_os_error();
return match err.raw_os_error() {
Some(libc::EAGAIN) | Some(libc::ENOSPC) | Some(libc::ENOBUFS) => Ok(false),
_ => Err(Error::Io {
op: "PUSH_SQ",
source: err,
}),
};
}
Ok(true)
}
fn pop_cq(&self) -> Result<Option<PoppedResponse>> {
let cap = self.cached_max_msg()?.max(8);
let mut buf = vec![0u8; cap];
let mut desc = ops::rsp_desc {
rsp: buf.as_mut_ptr() as *mut libc::c_void,
size: cap as u16,
cq_index: 0,
};
let rc = unsafe {
libc::ioctl(
self.raw(),
ioctl::POP_CQ,
(&raw mut desc).cast::<libc::c_void>(),
)
};
if rc < 0 {
let err = std::io::Error::last_os_error();
return match err.raw_os_error() {
Some(libc::EAGAIN) | Some(libc::ENOMSG) => Ok(None),
_ => Err(Error::Io {
op: "POP_CQ",
source: err,
}),
};
}
let len = if rc > 0 {
rc as usize
} else {
desc.size as usize
};
if len == 0 {
return Ok(None);
}
buf.truncate(len.min(cap));
Ok(Some(PoppedResponse {
bytes: buf,
cq_index: desc.cq_index,
}))
}
fn extract_trace(&self, trace_type: u8) -> Result<Vec<u8>> {
let mut ty = trace_type;
let size = unsafe {
ioctl::ioctl(
self.raw(),
ioctl::GET_TRACE_BUFFER_SIZE,
(&raw mut ty).cast(),
"GET_TRACE_BUFFER_SIZE",
)?
} as usize;
let mut buf = vec![0u8; size];
let mut desc: ops::trace_desc = unsafe { std::mem::zeroed() };
desc.trace_type = trace_type;
desc.buf = buf.as_mut_ptr() as *mut libc::c_void;
unsafe {
ioctl::ioctl(
self.raw(),
ioctl::EXTRACT_TRACE_BUFFER,
(&raw mut desc).cast(),
"EXTRACT_TRACE_BUFFER",
)?;
}
Ok(buf)
}
fn wait_cq(&self, timeout: Duration) -> Result<bool> {
self.poll(libc::POLLIN, timeout)
}
fn wait_sq(&self, timeout: Duration) -> Result<bool> {
self.poll(libc::POLLOUT, timeout)
}
fn dma_host_buffer(&self, size: usize) -> Result<Box<dyn DmaHostBuffer>> {
let len = size.max(1);
let ptr = unsafe {
libc::mmap(
std::ptr::null_mut(),
len,
libc::PROT_READ | libc::PROT_WRITE,
libc::MAP_SHARED,
self.raw(),
0,
)
};
if ptr == libc::MAP_FAILED {
return Err(Error::last_os("mmap(DMA buffer)"));
}
Ok(Box::new(MmapDmaBuffer {
ptr: ptr.cast(),
len,
}))
}
}
struct MmapDmaBuffer {
ptr: *mut u8,
len: usize,
}
impl DmaHostBuffer for MmapDmaBuffer {
fn as_mut_slice(&mut self) -> &mut [u8] {
unsafe { std::slice::from_raw_parts_mut(self.ptr, self.len) }
}
fn as_slice(&self) -> &[u8] {
unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
}
fn virt_addr(&self) -> u64 {
self.ptr as u64
}
fn phys_addr(&self) -> u64 {
0
}
}
impl Drop for MmapDmaBuffer {
fn drop(&mut self) {
unsafe { libc::munmap(self.ptr.cast(), self.len) };
}
}