pub mod cmd_flags {
use crate::ffi::ops::CMD_FLAGS;
pub const BARRIER: u16 = CMD_FLAGS::CMD_FLAGS_BARRIER_ENABLE as u16;
pub const COMPUTE_KERNEL_TRACE: u16 = CMD_FLAGS::CMD_FLAGS_COMPUTE_KERNEL_TRACE_ENABLE as u16;
pub const FLUSH_L3: u16 = CMD_FLAGS::CMD_FLAGS_KERNEL_LAUNCH_FLUSH_L3 as u16;
pub const KERNEL_ARGS_EMBEDDED: u16 = CMD_FLAGS::CMD_FLAGS_KERNEL_LAUNCH_ARGS_EMBEDDED as u16;
pub const USER_STACK_CFG: u16 = CMD_FLAGS::CMD_FLAGS_KERNEL_LAUNCH_USER_STACK_CFG as u16;
}
pub mod desc_flags {
use crate::ffi::ops::cmd_desc_flag;
pub const DMA: u8 = cmd_desc_flag::CMD_DESC_FLAG_DMA as u8;
pub const HIGH_PRIORITY: u8 = cmd_desc_flag::CMD_DESC_FLAG_HIGH_PRIORITY as u8;
pub const P2PDMA: u8 = cmd_desc_flag::CMD_DESC_FLAG_P2PDMA as u8;
}
pub mod msg_id {
use crate::ffi::ops::device_ops_api_msg_e as m;
pub const KERNEL_LAUNCH_CMD: u16 = m::DEV_OPS_API_MID_DEVICE_OPS_KERNEL_LAUNCH_CMD as u16;
pub const KERNEL_LAUNCH_RSP: u16 = m::DEV_OPS_API_MID_DEVICE_OPS_KERNEL_LAUNCH_RSP as u16;
pub const DMA_READLIST_CMD: u16 = m::DEV_OPS_API_MID_DEVICE_OPS_DMA_READLIST_CMD as u16;
pub const DMA_READLIST_RSP: u16 = m::DEV_OPS_API_MID_DEVICE_OPS_DMA_READLIST_RSP as u16;
pub const DMA_WRITELIST_CMD: u16 = m::DEV_OPS_API_MID_DEVICE_OPS_DMA_WRITELIST_CMD as u16;
pub const DMA_WRITELIST_RSP: u16 = m::DEV_OPS_API_MID_DEVICE_OPS_DMA_WRITELIST_RSP as u16;
}
pub const CMN_HEADER_SIZE: usize = 8;
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct CmnHeader {
pub size: u16,
pub tag_id: u16,
pub msg_id: u16,
pub flags: u16,
}
const _: () = assert!(core::mem::size_of::<CmnHeader>() == 8);
#[repr(C)]
#[derive(Clone, Copy, Debug, Default)]
pub struct DmaReadNode {
pub dst_host_virt_addr: u64,
pub dst_host_phy_addr: u64,
pub src_device_phy_addr: u64,
pub size: u32,
pub _pad: [u8; 4],
}
const _: () = assert!(core::mem::size_of::<DmaReadNode>() == 32);
#[repr(C)]
#[derive(Clone, Copy, Debug, Default)]
pub struct DmaWriteNode {
pub src_host_virt_addr: u64,
pub src_host_phy_addr: u64,
pub dst_device_phy_addr: u64,
pub size: u32,
pub _pad: [u8; 4],
}
const _: () = assert!(core::mem::size_of::<DmaWriteNode>() == 32);
#[repr(C)]
#[derive(Clone, Copy, Debug, Default)]
pub struct TraceInitInfo {
pub buffer: u64,
pub buffer_size: u32,
pub threshold: u32,
pub shire_mask: u64,
pub thread_mask: u64,
pub event_mask: u32,
pub filter_mask: u32,
}
const _: () = assert!(core::mem::size_of::<TraceInitInfo>() == 40);
#[repr(C)]
#[derive(Clone, Copy, Debug, Default)]
pub struct UserStackCfg {
pub stack_base_offset: u32,
pub stack_size: u32,
}
const _: () = assert!(core::mem::size_of::<UserStackCfg>() == 8);
impl TraceInitInfo {
pub fn to_bytes(&self) -> [u8; 40] {
let mut b = [0u8; 40];
b[0..8].copy_from_slice(&self.buffer.to_le_bytes());
b[8..12].copy_from_slice(&self.buffer_size.to_le_bytes());
b[12..16].copy_from_slice(&self.threshold.to_le_bytes());
b[16..24].copy_from_slice(&self.shire_mask.to_le_bytes());
b[24..32].copy_from_slice(&self.thread_mask.to_le_bytes());
b[32..36].copy_from_slice(&self.event_mask.to_le_bytes());
b[36..40].copy_from_slice(&self.filter_mask.to_le_bytes());
b
}
}
impl UserStackCfg {
pub fn to_bytes(&self) -> [u8; 8] {
let mut b = [0u8; 8];
b[0..4].copy_from_slice(&self.stack_base_offset.to_le_bytes());
b[4..8].copy_from_slice(&self.stack_size.to_le_bytes());
b
}
}
impl DmaReadNode {
pub fn to_bytes(&self) -> [u8; 32] {
let mut b = [0u8; 32];
b[0..8].copy_from_slice(&self.dst_host_virt_addr.to_le_bytes());
b[8..16].copy_from_slice(&self.dst_host_phy_addr.to_le_bytes());
b[16..24].copy_from_slice(&self.src_device_phy_addr.to_le_bytes());
b[24..28].copy_from_slice(&self.size.to_le_bytes());
b
}
}
impl DmaWriteNode {
pub fn to_bytes(&self) -> [u8; 32] {
let mut b = [0u8; 32];
b[0..8].copy_from_slice(&self.src_host_virt_addr.to_le_bytes());
b[8..16].copy_from_slice(&self.src_host_phy_addr.to_le_bytes());
b[16..24].copy_from_slice(&self.dst_device_phy_addr.to_le_bytes());
b[24..28].copy_from_slice(&self.size.to_le_bytes());
b
}
}
const KERNEL_LAUNCH_FIXED: usize = 32;
pub fn build_kernel_launch(
tag_id: u16,
flags: u16,
code_start_address: u64,
pointer_to_args: u64,
exception_buffer: u64,
shire_mask: u64,
payload: &[u8],
) -> Vec<u8> {
let payload_size = KERNEL_LAUNCH_FIXED + payload.len();
let total = CMN_HEADER_SIZE + payload_size;
let mut buf = Vec::with_capacity(total);
put_header(
&mut buf,
total as u16,
tag_id,
msg_id::KERNEL_LAUNCH_CMD,
flags,
);
buf.extend_from_slice(&code_start_address.to_le_bytes());
buf.extend_from_slice(&pointer_to_args.to_le_bytes());
buf.extend_from_slice(&exception_buffer.to_le_bytes());
buf.extend_from_slice(&shire_mask.to_le_bytes());
buf.extend_from_slice(payload);
buf
}
pub fn build_dma_readlist(tag_id: u16, flags: u16, nodes: &[DmaReadNode]) -> Vec<u8> {
let total = CMN_HEADER_SIZE + core::mem::size_of_val(nodes);
let mut buf = Vec::with_capacity(total);
put_header(
&mut buf,
total as u16,
tag_id,
msg_id::DMA_READLIST_CMD,
flags,
);
for node in nodes {
buf.extend_from_slice(&node.to_bytes());
}
buf
}
pub fn build_dma_writelist(tag_id: u16, flags: u16, nodes: &[DmaWriteNode]) -> Vec<u8> {
let total = CMN_HEADER_SIZE + core::mem::size_of_val(nodes);
let mut buf = Vec::with_capacity(total);
put_header(
&mut buf,
total as u16,
tag_id,
msg_id::DMA_WRITELIST_CMD,
flags,
);
for node in nodes {
buf.extend_from_slice(&node.to_bytes());
}
buf
}
fn put_header(buf: &mut Vec<u8>, size: u16, tag_id: u16, msg_id: u16, flags: u16) {
buf.extend_from_slice(&size.to_le_bytes());
buf.extend_from_slice(&tag_id.to_le_bytes());
buf.extend_from_slice(&msg_id.to_le_bytes());
buf.extend_from_slice(&flags.to_le_bytes());
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ResponseHeader {
pub size: u16,
pub tag_id: u16,
pub msg_id: u16,
pub flags: u16,
}
impl ResponseHeader {
pub fn parse(buf: &[u8]) -> Option<ResponseHeader> {
if buf.len() < 8 {
return None;
}
Some(ResponseHeader {
size: u16::from_le_bytes([buf[0], buf[1]]),
tag_id: u16::from_le_bytes([buf[2], buf[3]]),
msg_id: u16::from_le_bytes([buf[4], buf[5]]),
flags: u16::from_le_bytes([buf[6], buf[7]]),
})
}
}
pub const RSP_STATUS_OFFSET: usize = 8 + 8 + 8 + 8;
pub fn response_status(buf: &[u8]) -> Option<u32> {
let end = RSP_STATUS_OFFSET + 4;
if buf.len() < end {
return None;
}
Some(u32::from_le_bytes([
buf[RSP_STATUS_OFFSET],
buf[RSP_STATUS_OFFSET + 1],
buf[RSP_STATUS_OFFSET + 2],
buf[RSP_STATUS_OFFSET + 3],
]))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct KernelErrorPtr {
pub exception_buffer: u64,
pub trace_buffer: u64,
pub shire_mask: u64,
}
pub const RSP_KERNEL_ERROR_PTR_OFFSET: usize = RSP_STATUS_OFFSET + 8;
pub fn parse_kernel_error_ptr(buf: &[u8]) -> Option<KernelErrorPtr> {
let start = RSP_KERNEL_ERROR_PTR_OFFSET;
if buf.len() < start + 24 {
return None;
}
let read = |o: usize| u64::from_le_bytes(buf[o..o + 8].try_into().unwrap());
Some(KernelErrorPtr {
exception_buffer: read(start),
trace_buffer: read(start + 8),
shire_mask: read(start + 16),
})
}
pub fn kernel_launch_status_name(status: u32) -> &'static str {
use crate::ffi::ops::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE as r;
match status {
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_KERNEL_COMPLETED => "KERNEL_COMPLETED",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_UNEXPECTED_ERROR => "UNEXPECTED_ERROR",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_EXCEPTION => "EXCEPTION",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_SHIRES_NOT_READY => "SHIRES_NOT_READY",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_HOST_ABORTED => "HOST_ABORTED",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_INVALID_ADDRESS => "INVALID_ADDRESS",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_TIMEOUT_HANG => "TIMEOUT_HANG",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_INVALID_ARGS_PAYLOAD_SIZE => {
"INVALID_ARGS_PAYLOAD_SIZE"
}
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_CM_IFACE_MULTICAST_FAILED => {
"CM_IFACE_MULTICAST_FAILED"
}
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_CM_IFACE_UNICAST_FAILED => {
"CM_IFACE_UNICAST_FAILED"
}
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_SP_IFACE_RESET_FAILED => {
"SP_IFACE_RESET_FAILED"
}
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_CW_MINIONS_BOOT_FAILED => {
"CW_MINIONS_BOOT_FAILED"
}
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_INVALID_ARGS_INVALID_SHIRE_MASK => {
"INVALID_ARGS_INVALID_SHIRE_MASK"
}
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_USER_ERROR => "USER_ERROR",
s if s == r::DEV_OPS_API_KERNEL_LAUNCH_RESPONSE_INVALID_ARGS_INVALID_STACK_CFG => {
"INVALID_ARGS_INVALID_STACK_CFG"
}
_ => "UNKNOWN",
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn kernel_launch_header_and_fields() {
let payload = [0xAAu8; 40];
let cmd = build_kernel_launch(7, cmd_flags::BARRIER, 0x8005801000, 0, 0, 0x1, &payload);
let hdr = ResponseHeader::parse(&cmd).unwrap();
assert_eq!(
hdr.size as usize,
CMN_HEADER_SIZE + KERNEL_LAUNCH_FIXED + payload.len()
);
assert_eq!(hdr.size as usize, cmd.len());
assert_eq!(hdr.tag_id, 7);
assert_eq!(hdr.msg_id, msg_id::KERNEL_LAUNCH_CMD);
assert_eq!(hdr.flags, cmd_flags::BARRIER);
let code_start = u64::from_le_bytes(cmd[8..16].try_into().unwrap());
let shire_mask = u64::from_le_bytes(cmd[32..40].try_into().unwrap());
assert_eq!(code_start, 0x8005801000);
assert_eq!(shire_mask, 0x1);
assert_eq!(cmd.len(), 8 + KERNEL_LAUNCH_FIXED + payload.len());
}
#[test]
fn dma_readlist_layout() {
let nodes = [
DmaReadNode {
dst_host_virt_addr: 0x1111,
dst_host_phy_addr: 0,
src_device_phy_addr: 0x80_0000_0000,
size: 64,
_pad: [0; 4],
},
DmaReadNode {
dst_host_virt_addr: 0x2222,
dst_host_phy_addr: 0,
src_device_phy_addr: 0x80_0000_1000,
size: 128,
_pad: [0; 4],
},
];
let cmd = build_dma_readlist(3, cmd_flags::BARRIER, &nodes);
let hdr = ResponseHeader::parse(&cmd).unwrap();
assert_eq!(hdr.msg_id, msg_id::DMA_READLIST_CMD);
assert_eq!(hdr.size as usize, CMN_HEADER_SIZE + nodes.len() * 32);
assert_eq!(hdr.size as usize, cmd.len());
let src1 = u64::from_le_bytes(cmd[8 + 32 + 16..8 + 32 + 24].try_into().unwrap());
assert_eq!(src1, 0x80_0000_1000);
}
#[test]
fn status_reads_at_offset_32() {
let mut rsp = vec![0u8; 40];
rsp[RSP_STATUS_OFFSET..RSP_STATUS_OFFSET + 4].copy_from_slice(&13u32.to_le_bytes());
assert_eq!(response_status(&rsp), Some(13));
assert_eq!(response_status(&rsp[..RSP_STATUS_OFFSET]), None);
}
#[test]
fn launch_status_names_map_known_codes() {
assert_eq!(kernel_launch_status_name(0), "KERNEL_COMPLETED");
assert_eq!(kernel_launch_status_name(2), "EXCEPTION");
assert_eq!(kernel_launch_status_name(6), "TIMEOUT_HANG");
assert_eq!(kernel_launch_status_name(13), "USER_ERROR");
assert_eq!(kernel_launch_status_name(9999), "UNKNOWN");
}
#[test]
fn error_ptr_parses_when_appended() {
let mut rsp = vec![0u8; RSP_KERNEL_ERROR_PTR_OFFSET + 24];
let base = RSP_KERNEL_ERROR_PTR_OFFSET;
rsp[base..base + 8].copy_from_slice(&0x1111u64.to_le_bytes());
rsp[base + 8..base + 16].copy_from_slice(&0x2222u64.to_le_bytes());
rsp[base + 16..base + 24].copy_from_slice(&0x3u64.to_le_bytes());
let e = parse_kernel_error_ptr(&rsp).unwrap();
assert_eq!(e.exception_buffer, 0x1111);
assert_eq!(e.trace_buffer, 0x2222);
assert_eq!(e.shire_mask, 0x3);
assert!(parse_kernel_error_ptr(&rsp[..RSP_KERNEL_ERROR_PTR_OFFSET]).is_none());
}
}