972 lines
31 KiB
Rust
972 lines
31 KiB
Rust
use core_io::{Error as IoError, Read, Write};
|
|
use io::proto::{ProtoRead, ProtoWrite};
|
|
|
|
// maximum size of arbitrary payloads
|
|
// used by satellite -> master analyzer, subkernel exceptions
|
|
pub const SAT_PAYLOAD_MAX_SIZE: usize = /*max size*/512 - /*CRC*/4 - /*packet ID*/1 - /*last*/1 - /*length*/2;
|
|
// used by DDMA, subkernel program data (need to provide extra ID and destination)
|
|
pub const MASTER_PAYLOAD_MAX_SIZE: usize = SAT_PAYLOAD_MAX_SIZE - /*source*/1 - /*destination*/1 - /*ID*/4;
|
|
|
|
#[derive(Debug)]
|
|
pub enum Error {
|
|
UnknownPacket(u8),
|
|
Io(IoError),
|
|
}
|
|
|
|
impl From<IoError> for Error {
|
|
fn from(value: IoError) -> Error {
|
|
Error::Io(value)
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Clone, Copy, Debug)]
|
|
#[repr(u8)]
|
|
pub enum PayloadStatus {
|
|
Middle = 0,
|
|
First = 1,
|
|
Last = 2,
|
|
FirstAndLast = 3,
|
|
}
|
|
|
|
impl From<u8> for PayloadStatus {
|
|
fn from(value: u8) -> PayloadStatus {
|
|
match value {
|
|
0 => PayloadStatus::Middle,
|
|
1 => PayloadStatus::First,
|
|
2 => PayloadStatus::Last,
|
|
3 => PayloadStatus::FirstAndLast,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PayloadStatus {
|
|
pub fn is_first(self) -> bool {
|
|
self == PayloadStatus::First || self == PayloadStatus::FirstAndLast
|
|
}
|
|
|
|
pub fn is_last(self) -> bool {
|
|
self == PayloadStatus::Last || self == PayloadStatus::FirstAndLast
|
|
}
|
|
|
|
pub fn from_status(first: bool, last: bool) -> PayloadStatus {
|
|
match (first, last) {
|
|
(true, true) => PayloadStatus::FirstAndLast,
|
|
(true, false) => PayloadStatus::First,
|
|
(false, true) => PayloadStatus::Last,
|
|
(false, false) => PayloadStatus::Middle,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Debug)]
|
|
pub enum Packet {
|
|
EchoRequest,
|
|
EchoReply,
|
|
ResetRequest,
|
|
ResetAck,
|
|
TSCAck,
|
|
|
|
DestinationStatusRequest {
|
|
destination: u8,
|
|
},
|
|
DestinationDownReply,
|
|
DestinationOkReply,
|
|
DestinationSequenceErrorReply {
|
|
channel: u16,
|
|
},
|
|
DestinationCollisionReply {
|
|
channel: u16,
|
|
},
|
|
DestinationBusyReply {
|
|
channel: u16,
|
|
},
|
|
|
|
RoutingSetPath {
|
|
destination: u8,
|
|
hops: [u8; 32],
|
|
},
|
|
RoutingSetRank {
|
|
rank: u8,
|
|
},
|
|
RoutingRetrievePackets,
|
|
RoutingNoPackets,
|
|
RoutingAck,
|
|
|
|
MonitorRequest {
|
|
destination: u8,
|
|
channel: u16,
|
|
probe: u8,
|
|
},
|
|
MonitorReply {
|
|
value: u64,
|
|
},
|
|
InjectionRequest {
|
|
destination: u8,
|
|
channel: u16,
|
|
overrd: u8,
|
|
value: u8,
|
|
},
|
|
InjectionStatusRequest {
|
|
destination: u8,
|
|
channel: u16,
|
|
overrd: u8,
|
|
},
|
|
InjectionStatusReply {
|
|
value: u8,
|
|
},
|
|
|
|
I2cStartRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
},
|
|
I2cRestartRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
},
|
|
I2cStopRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
},
|
|
I2cWriteRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
data: u8,
|
|
},
|
|
I2cWriteReply {
|
|
succeeded: bool,
|
|
ack: bool,
|
|
},
|
|
I2cReadRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
ack: bool,
|
|
},
|
|
I2cReadReply {
|
|
succeeded: bool,
|
|
data: u8,
|
|
},
|
|
I2cBasicReply {
|
|
succeeded: bool,
|
|
},
|
|
I2cSwitchSelectRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
address: u8,
|
|
mask: u8,
|
|
},
|
|
|
|
SpiSetConfigRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
flags: u8,
|
|
length: u8,
|
|
div: u8,
|
|
cs: u8,
|
|
},
|
|
SpiWriteRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
data: u32,
|
|
},
|
|
SpiReadRequest {
|
|
destination: u8,
|
|
busno: u8,
|
|
},
|
|
SpiReadReply {
|
|
succeeded: bool,
|
|
data: u32,
|
|
},
|
|
SpiBasicReply {
|
|
succeeded: bool,
|
|
},
|
|
|
|
AnalyzerHeaderRequest {
|
|
destination: u8,
|
|
},
|
|
AnalyzerHeader {
|
|
sent_bytes: u32,
|
|
total_byte_count: u64,
|
|
overflow_occurred: bool,
|
|
},
|
|
AnalyzerDataRequest {
|
|
destination: u8,
|
|
},
|
|
AnalyzerData {
|
|
last: bool,
|
|
length: u16,
|
|
data: [u8; SAT_PAYLOAD_MAX_SIZE],
|
|
},
|
|
|
|
DmaAddTraceRequest {
|
|
source: u8,
|
|
destination: u8,
|
|
id: u32,
|
|
status: PayloadStatus,
|
|
length: u16,
|
|
trace: [u8; MASTER_PAYLOAD_MAX_SIZE],
|
|
},
|
|
DmaAddTraceReply {
|
|
source: u8,
|
|
destination: u8,
|
|
id: u32,
|
|
succeeded: bool,
|
|
},
|
|
DmaRemoveTraceRequest {
|
|
source: u8,
|
|
destination: u8,
|
|
id: u32,
|
|
},
|
|
DmaRemoveTraceReply {
|
|
destination: u8,
|
|
succeeded: bool,
|
|
},
|
|
DmaPlaybackRequest {
|
|
source: u8,
|
|
destination: u8,
|
|
id: u32,
|
|
timestamp: u64,
|
|
},
|
|
DmaPlaybackReply {
|
|
destination: u8,
|
|
succeeded: bool,
|
|
},
|
|
DmaPlaybackStatus {
|
|
source: u8,
|
|
destination: u8,
|
|
id: u32,
|
|
error: u8,
|
|
channel: u32,
|
|
timestamp: u64,
|
|
},
|
|
|
|
SubkernelAddDataRequest {
|
|
destination: u8,
|
|
id: u32,
|
|
status: PayloadStatus,
|
|
length: u16,
|
|
data: [u8; MASTER_PAYLOAD_MAX_SIZE],
|
|
},
|
|
SubkernelAddDataReply {
|
|
succeeded: bool,
|
|
},
|
|
SubkernelLoadRunRequest {
|
|
source: u8,
|
|
destination: u8,
|
|
id: u32,
|
|
run: bool,
|
|
},
|
|
SubkernelLoadRunReply {
|
|
destination: u8,
|
|
succeeded: bool,
|
|
},
|
|
SubkernelFinished {
|
|
destination: u8,
|
|
id: u32,
|
|
with_exception: bool,
|
|
exception_src: u8,
|
|
},
|
|
SubkernelExceptionRequest {
|
|
destination: u8,
|
|
},
|
|
SubkernelException {
|
|
last: bool,
|
|
length: u16,
|
|
data: [u8; SAT_PAYLOAD_MAX_SIZE],
|
|
},
|
|
SubkernelMessage {
|
|
source: u8,
|
|
destination: u8,
|
|
id: u32,
|
|
status: PayloadStatus,
|
|
length: u16,
|
|
data: [u8; MASTER_PAYLOAD_MAX_SIZE],
|
|
},
|
|
SubkernelMessageAck {
|
|
destination: u8,
|
|
},
|
|
}
|
|
|
|
impl Packet {
|
|
pub fn read_from<R>(reader: &mut R) -> Result<Self, Error>
|
|
where R: Read + ?Sized {
|
|
Ok(match reader.read_u8()? {
|
|
0x00 => Packet::EchoRequest,
|
|
0x01 => Packet::EchoReply,
|
|
0x02 => Packet::ResetRequest,
|
|
0x03 => Packet::ResetAck,
|
|
0x04 => Packet::TSCAck,
|
|
|
|
0x20 => Packet::DestinationStatusRequest {
|
|
destination: reader.read_u8()?,
|
|
},
|
|
0x21 => Packet::DestinationDownReply,
|
|
0x22 => Packet::DestinationOkReply,
|
|
0x23 => Packet::DestinationSequenceErrorReply {
|
|
channel: reader.read_u16()?,
|
|
},
|
|
0x24 => Packet::DestinationCollisionReply {
|
|
channel: reader.read_u16()?,
|
|
},
|
|
0x25 => Packet::DestinationBusyReply {
|
|
channel: reader.read_u16()?,
|
|
},
|
|
|
|
0x30 => {
|
|
let destination = reader.read_u8()?;
|
|
let mut hops = [0; 32];
|
|
reader.read_exact(&mut hops)?;
|
|
Packet::RoutingSetPath {
|
|
destination: destination,
|
|
hops: hops,
|
|
}
|
|
}
|
|
0x31 => Packet::RoutingSetRank {
|
|
rank: reader.read_u8()?,
|
|
},
|
|
0x32 => Packet::RoutingAck,
|
|
0x33 => Packet::RoutingRetrievePackets,
|
|
0x34 => Packet::RoutingNoPackets,
|
|
|
|
0x40 => Packet::MonitorRequest {
|
|
destination: reader.read_u8()?,
|
|
channel: reader.read_u16()?,
|
|
probe: reader.read_u8()?,
|
|
},
|
|
0x41 => Packet::MonitorReply {
|
|
value: reader.read_u64()?,
|
|
},
|
|
0x50 => Packet::InjectionRequest {
|
|
destination: reader.read_u8()?,
|
|
channel: reader.read_u16()?,
|
|
overrd: reader.read_u8()?,
|
|
value: reader.read_u8()?,
|
|
},
|
|
0x51 => Packet::InjectionStatusRequest {
|
|
destination: reader.read_u8()?,
|
|
channel: reader.read_u16()?,
|
|
overrd: reader.read_u8()?,
|
|
},
|
|
0x52 => Packet::InjectionStatusReply {
|
|
value: reader.read_u8()?,
|
|
},
|
|
|
|
0x80 => Packet::I2cStartRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
},
|
|
0x81 => Packet::I2cRestartRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
},
|
|
0x82 => Packet::I2cStopRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
},
|
|
0x83 => Packet::I2cWriteRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
data: reader.read_u8()?,
|
|
},
|
|
0x84 => Packet::I2cWriteReply {
|
|
succeeded: reader.read_bool()?,
|
|
ack: reader.read_bool()?,
|
|
},
|
|
0x85 => Packet::I2cReadRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
ack: reader.read_bool()?,
|
|
},
|
|
0x86 => Packet::I2cReadReply {
|
|
succeeded: reader.read_bool()?,
|
|
data: reader.read_u8()?,
|
|
},
|
|
0x87 => Packet::I2cBasicReply {
|
|
succeeded: reader.read_bool()?,
|
|
},
|
|
0x88 => Packet::I2cSwitchSelectRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
address: reader.read_u8()?,
|
|
mask: reader.read_u8()?,
|
|
},
|
|
|
|
0x90 => Packet::SpiSetConfigRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
flags: reader.read_u8()?,
|
|
length: reader.read_u8()?,
|
|
div: reader.read_u8()?,
|
|
cs: reader.read_u8()?,
|
|
},
|
|
/* 0x91: was Packet::SpiSetXferRequest */
|
|
0x92 => Packet::SpiWriteRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
data: reader.read_u32()?,
|
|
},
|
|
0x93 => Packet::SpiReadRequest {
|
|
destination: reader.read_u8()?,
|
|
busno: reader.read_u8()?,
|
|
},
|
|
0x94 => Packet::SpiReadReply {
|
|
succeeded: reader.read_bool()?,
|
|
data: reader.read_u32()?,
|
|
},
|
|
0x95 => Packet::SpiBasicReply {
|
|
succeeded: reader.read_bool()?,
|
|
},
|
|
|
|
0xa0 => Packet::AnalyzerHeaderRequest {
|
|
destination: reader.read_u8()?,
|
|
},
|
|
0xa1 => Packet::AnalyzerHeader {
|
|
sent_bytes: reader.read_u32()?,
|
|
total_byte_count: reader.read_u64()?,
|
|
overflow_occurred: reader.read_bool()?,
|
|
},
|
|
0xa2 => Packet::AnalyzerDataRequest {
|
|
destination: reader.read_u8()?,
|
|
},
|
|
0xa3 => {
|
|
let last = reader.read_bool()?;
|
|
let length = reader.read_u16()?;
|
|
let mut data: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
|
|
reader.read_exact(&mut data[0..length as usize])?;
|
|
Packet::AnalyzerData {
|
|
last: last,
|
|
length: length,
|
|
data: data,
|
|
}
|
|
}
|
|
|
|
0xb0 => {
|
|
let source = reader.read_u8()?;
|
|
let destination = reader.read_u8()?;
|
|
let id = reader.read_u32()?;
|
|
let status = reader.read_u8()?;
|
|
let length = reader.read_u16()?;
|
|
let mut trace: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
|
|
reader.read_exact(&mut trace[0..length as usize])?;
|
|
Packet::DmaAddTraceRequest {
|
|
source: source,
|
|
destination: destination,
|
|
id: id,
|
|
status: PayloadStatus::from(status),
|
|
length: length as u16,
|
|
trace: trace,
|
|
}
|
|
}
|
|
0xb1 => Packet::DmaAddTraceReply {
|
|
source: reader.read_u8()?,
|
|
destination: reader.read_u8()?,
|
|
id: reader.read_u32()?,
|
|
succeeded: reader.read_bool()?,
|
|
},
|
|
0xb2 => Packet::DmaRemoveTraceRequest {
|
|
source: reader.read_u8()?,
|
|
destination: reader.read_u8()?,
|
|
id: reader.read_u32()?,
|
|
},
|
|
0xb3 => Packet::DmaRemoveTraceReply {
|
|
destination: reader.read_u8()?,
|
|
succeeded: reader.read_bool()?,
|
|
},
|
|
0xb4 => Packet::DmaPlaybackRequest {
|
|
source: reader.read_u8()?,
|
|
destination: reader.read_u8()?,
|
|
id: reader.read_u32()?,
|
|
timestamp: reader.read_u64()?,
|
|
},
|
|
0xb5 => Packet::DmaPlaybackReply {
|
|
destination: reader.read_u8()?,
|
|
succeeded: reader.read_bool()?,
|
|
},
|
|
0xb6 => Packet::DmaPlaybackStatus {
|
|
source: reader.read_u8()?,
|
|
destination: reader.read_u8()?,
|
|
id: reader.read_u32()?,
|
|
error: reader.read_u8()?,
|
|
channel: reader.read_u32()?,
|
|
timestamp: reader.read_u64()?,
|
|
},
|
|
|
|
0xc0 => {
|
|
let destination = reader.read_u8()?;
|
|
let id = reader.read_u32()?;
|
|
let status = PayloadStatus::from(reader.read_u8()?);
|
|
let length = reader.read_u16()?;
|
|
let mut data: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
|
|
reader.read_exact(&mut data[0..length as usize])?;
|
|
Packet::SubkernelAddDataRequest {
|
|
destination: destination,
|
|
id: id,
|
|
status: status,
|
|
length: length as u16,
|
|
data: data,
|
|
}
|
|
}
|
|
0xc1 => Packet::SubkernelAddDataReply {
|
|
succeeded: reader.read_bool()?,
|
|
},
|
|
0xc4 => Packet::SubkernelLoadRunRequest {
|
|
source: reader.read_u8()?,
|
|
destination: reader.read_u8()?,
|
|
id: reader.read_u32()?,
|
|
run: reader.read_bool()?,
|
|
},
|
|
0xc5 => Packet::SubkernelLoadRunReply {
|
|
destination: reader.read_u8()?,
|
|
succeeded: reader.read_bool()?,
|
|
},
|
|
0xc8 => Packet::SubkernelFinished {
|
|
destination: reader.read_u8()?,
|
|
id: reader.read_u32()?,
|
|
with_exception: reader.read_bool()?,
|
|
exception_src: reader.read_u8()?,
|
|
},
|
|
0xc9 => Packet::SubkernelExceptionRequest {
|
|
destination: reader.read_u8()?,
|
|
},
|
|
0xca => {
|
|
let last = reader.read_bool()?;
|
|
let length = reader.read_u16()?;
|
|
let mut data: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
|
|
reader.read_exact(&mut data[0..length as usize])?;
|
|
Packet::SubkernelException {
|
|
last: last,
|
|
length: length,
|
|
data: data,
|
|
}
|
|
}
|
|
0xcb => {
|
|
let source = reader.read_u8()?;
|
|
let destination = reader.read_u8()?;
|
|
let id = reader.read_u32()?;
|
|
let status = reader.read_u8()?;
|
|
let length = reader.read_u16()?;
|
|
let mut data: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
|
|
reader.read_exact(&mut data[0..length as usize])?;
|
|
Packet::SubkernelMessage {
|
|
source: source,
|
|
destination: destination,
|
|
id: id,
|
|
status: PayloadStatus::from(status),
|
|
length: length as u16,
|
|
data: data,
|
|
}
|
|
}
|
|
0xcc => Packet::SubkernelMessageAck {
|
|
destination: reader.read_u8()?,
|
|
},
|
|
|
|
ty => return Err(Error::UnknownPacket(ty)),
|
|
})
|
|
}
|
|
|
|
pub fn write_to<W>(&self, writer: &mut W) -> Result<(), IoError>
|
|
where W: Write + ?Sized {
|
|
match *self {
|
|
Packet::EchoRequest => writer.write_u8(0x00)?,
|
|
Packet::EchoReply => writer.write_u8(0x01)?,
|
|
Packet::ResetRequest => writer.write_u8(0x02)?,
|
|
Packet::ResetAck => writer.write_u8(0x03)?,
|
|
Packet::TSCAck => writer.write_u8(0x04)?,
|
|
|
|
Packet::DestinationStatusRequest { destination } => {
|
|
writer.write_u8(0x20)?;
|
|
writer.write_u8(destination)?;
|
|
}
|
|
Packet::DestinationDownReply => writer.write_u8(0x21)?,
|
|
Packet::DestinationOkReply => writer.write_u8(0x22)?,
|
|
Packet::DestinationSequenceErrorReply { channel } => {
|
|
writer.write_u8(0x23)?;
|
|
writer.write_u16(channel)?;
|
|
}
|
|
Packet::DestinationCollisionReply { channel } => {
|
|
writer.write_u8(0x24)?;
|
|
writer.write_u16(channel)?;
|
|
}
|
|
Packet::DestinationBusyReply { channel } => {
|
|
writer.write_u8(0x25)?;
|
|
writer.write_u16(channel)?;
|
|
}
|
|
|
|
Packet::RoutingSetPath { destination, hops } => {
|
|
writer.write_u8(0x30)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_all(&hops)?;
|
|
}
|
|
Packet::RoutingSetRank { rank } => {
|
|
writer.write_u8(0x31)?;
|
|
writer.write_u8(rank)?;
|
|
}
|
|
Packet::RoutingAck => writer.write_u8(0x32)?,
|
|
Packet::RoutingRetrievePackets => writer.write_u8(0x33)?,
|
|
Packet::RoutingNoPackets => writer.write_u8(0x34)?,
|
|
|
|
Packet::MonitorRequest {
|
|
destination,
|
|
channel,
|
|
probe,
|
|
} => {
|
|
writer.write_u8(0x40)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u16(channel)?;
|
|
writer.write_u8(probe)?;
|
|
}
|
|
Packet::MonitorReply { value } => {
|
|
writer.write_u8(0x41)?;
|
|
writer.write_u64(value)?;
|
|
}
|
|
Packet::InjectionRequest {
|
|
destination,
|
|
channel,
|
|
overrd,
|
|
value,
|
|
} => {
|
|
writer.write_u8(0x50)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u16(channel)?;
|
|
writer.write_u8(overrd)?;
|
|
writer.write_u8(value)?;
|
|
}
|
|
Packet::InjectionStatusRequest {
|
|
destination,
|
|
channel,
|
|
overrd,
|
|
} => {
|
|
writer.write_u8(0x51)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u16(channel)?;
|
|
writer.write_u8(overrd)?;
|
|
}
|
|
Packet::InjectionStatusReply { value } => {
|
|
writer.write_u8(0x52)?;
|
|
writer.write_u8(value)?;
|
|
}
|
|
|
|
Packet::I2cStartRequest { destination, busno } => {
|
|
writer.write_u8(0x80)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
}
|
|
Packet::I2cRestartRequest { destination, busno } => {
|
|
writer.write_u8(0x81)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
}
|
|
Packet::I2cStopRequest { destination, busno } => {
|
|
writer.write_u8(0x82)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
}
|
|
Packet::I2cWriteRequest {
|
|
destination,
|
|
busno,
|
|
data,
|
|
} => {
|
|
writer.write_u8(0x83)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
writer.write_u8(data)?;
|
|
}
|
|
Packet::I2cWriteReply { succeeded, ack } => {
|
|
writer.write_u8(0x84)?;
|
|
writer.write_bool(succeeded)?;
|
|
writer.write_bool(ack)?;
|
|
}
|
|
Packet::I2cReadRequest {
|
|
destination,
|
|
busno,
|
|
ack,
|
|
} => {
|
|
writer.write_u8(0x85)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
writer.write_bool(ack)?;
|
|
}
|
|
Packet::I2cReadReply { succeeded, data } => {
|
|
writer.write_u8(0x86)?;
|
|
writer.write_bool(succeeded)?;
|
|
writer.write_u8(data)?;
|
|
}
|
|
Packet::I2cBasicReply { succeeded } => {
|
|
writer.write_u8(0x87)?;
|
|
writer.write_bool(succeeded)?;
|
|
}
|
|
Packet::I2cSwitchSelectRequest {
|
|
destination,
|
|
busno,
|
|
address,
|
|
mask,
|
|
} => {
|
|
writer.write_u8(0x88)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
writer.write_u8(address)?;
|
|
writer.write_u8(mask)?;
|
|
}
|
|
|
|
Packet::SpiSetConfigRequest {
|
|
destination,
|
|
busno,
|
|
flags,
|
|
length,
|
|
div,
|
|
cs,
|
|
} => {
|
|
writer.write_u8(0x90)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
writer.write_u8(flags)?;
|
|
writer.write_u8(length)?;
|
|
writer.write_u8(div)?;
|
|
writer.write_u8(cs)?;
|
|
}
|
|
Packet::SpiWriteRequest {
|
|
destination,
|
|
busno,
|
|
data,
|
|
} => {
|
|
writer.write_u8(0x92)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
writer.write_u32(data)?;
|
|
}
|
|
Packet::SpiReadRequest { destination, busno } => {
|
|
writer.write_u8(0x93)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u8(busno)?;
|
|
}
|
|
Packet::SpiReadReply { succeeded, data } => {
|
|
writer.write_u8(0x94)?;
|
|
writer.write_bool(succeeded)?;
|
|
writer.write_u32(data)?;
|
|
}
|
|
Packet::SpiBasicReply { succeeded } => {
|
|
writer.write_u8(0x95)?;
|
|
writer.write_bool(succeeded)?;
|
|
}
|
|
|
|
Packet::AnalyzerHeaderRequest { destination } => {
|
|
writer.write_u8(0xa0)?;
|
|
writer.write_u8(destination)?;
|
|
}
|
|
Packet::AnalyzerHeader {
|
|
sent_bytes,
|
|
total_byte_count,
|
|
overflow_occurred,
|
|
} => {
|
|
writer.write_u8(0xa1)?;
|
|
writer.write_u32(sent_bytes)?;
|
|
writer.write_u64(total_byte_count)?;
|
|
writer.write_bool(overflow_occurred)?;
|
|
}
|
|
Packet::AnalyzerDataRequest { destination } => {
|
|
writer.write_u8(0xa2)?;
|
|
writer.write_u8(destination)?;
|
|
}
|
|
Packet::AnalyzerData { last, length, data } => {
|
|
writer.write_u8(0xa3)?;
|
|
writer.write_bool(last)?;
|
|
writer.write_u16(length)?;
|
|
writer.write_all(&data[0..length as usize])?;
|
|
}
|
|
|
|
Packet::DmaAddTraceRequest {
|
|
source,
|
|
destination,
|
|
id,
|
|
status,
|
|
trace,
|
|
length,
|
|
} => {
|
|
writer.write_u8(0xb0)?;
|
|
writer.write_u8(source)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_u8(status as u8)?;
|
|
// trace may be broken down to fit within drtio aux memory limit
|
|
// will be reconstructed by satellite
|
|
writer.write_u16(length)?;
|
|
writer.write_all(&trace[0..length as usize])?;
|
|
}
|
|
Packet::DmaAddTraceReply {
|
|
source,
|
|
destination,
|
|
id,
|
|
succeeded,
|
|
} => {
|
|
writer.write_u8(0xb1)?;
|
|
writer.write_u8(source)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_bool(succeeded)?;
|
|
}
|
|
Packet::DmaRemoveTraceRequest {
|
|
source,
|
|
destination,
|
|
id,
|
|
} => {
|
|
writer.write_u8(0xb2)?;
|
|
writer.write_u8(source)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
}
|
|
Packet::DmaRemoveTraceReply { destination, succeeded } => {
|
|
writer.write_u8(0xb3)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_bool(succeeded)?;
|
|
}
|
|
Packet::DmaPlaybackRequest {
|
|
source,
|
|
destination,
|
|
id,
|
|
timestamp,
|
|
} => {
|
|
writer.write_u8(0xb4)?;
|
|
writer.write_u8(source)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_u64(timestamp)?;
|
|
}
|
|
Packet::DmaPlaybackReply { destination, succeeded } => {
|
|
writer.write_u8(0xb5)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_bool(succeeded)?;
|
|
}
|
|
Packet::DmaPlaybackStatus {
|
|
source,
|
|
destination,
|
|
id,
|
|
error,
|
|
channel,
|
|
timestamp,
|
|
} => {
|
|
writer.write_u8(0xb6)?;
|
|
writer.write_u8(source)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_u8(error)?;
|
|
writer.write_u32(channel)?;
|
|
writer.write_u64(timestamp)?;
|
|
}
|
|
|
|
Packet::SubkernelAddDataRequest {
|
|
destination,
|
|
id,
|
|
status,
|
|
data,
|
|
length,
|
|
} => {
|
|
writer.write_u8(0xc0)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_u8(status as u8)?;
|
|
writer.write_u16(length)?;
|
|
writer.write_all(&data[0..length as usize])?;
|
|
}
|
|
Packet::SubkernelAddDataReply { succeeded } => {
|
|
writer.write_u8(0xc1)?;
|
|
writer.write_bool(succeeded)?;
|
|
}
|
|
Packet::SubkernelLoadRunRequest {
|
|
source,
|
|
destination,
|
|
id,
|
|
run,
|
|
} => {
|
|
writer.write_u8(0xc4)?;
|
|
writer.write_u8(source)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_bool(run)?;
|
|
}
|
|
Packet::SubkernelLoadRunReply { destination, succeeded } => {
|
|
writer.write_u8(0xc5)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_bool(succeeded)?;
|
|
}
|
|
Packet::SubkernelFinished {
|
|
destination,
|
|
id,
|
|
with_exception,
|
|
exception_src,
|
|
} => {
|
|
writer.write_u8(0xc8)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_bool(with_exception)?;
|
|
writer.write_u8(exception_src)?;
|
|
}
|
|
Packet::SubkernelExceptionRequest { destination } => {
|
|
writer.write_u8(0xc9)?;
|
|
writer.write_u8(destination)?;
|
|
}
|
|
Packet::SubkernelException { last, length, data } => {
|
|
writer.write_u8(0xca)?;
|
|
writer.write_bool(last)?;
|
|
writer.write_u16(length)?;
|
|
writer.write_all(&data[0..length as usize])?;
|
|
}
|
|
Packet::SubkernelMessage {
|
|
source,
|
|
destination,
|
|
id,
|
|
status,
|
|
data,
|
|
length,
|
|
} => {
|
|
writer.write_u8(0xcb)?;
|
|
writer.write_u8(source)?;
|
|
writer.write_u8(destination)?;
|
|
writer.write_u32(id)?;
|
|
writer.write_u8(status as u8)?;
|
|
writer.write_u16(length)?;
|
|
writer.write_all(&data[0..length as usize])?;
|
|
}
|
|
Packet::SubkernelMessageAck { destination } => {
|
|
writer.write_u8(0xcc)?;
|
|
writer.write_u8(destination)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn routable_destination(&self) -> Option<u8> {
|
|
// only for packets that could be re-routed, not only forwarded
|
|
match self {
|
|
Packet::DmaAddTraceRequest { destination, .. } => Some(*destination),
|
|
Packet::DmaAddTraceReply { destination, .. } => Some(*destination),
|
|
Packet::DmaRemoveTraceRequest { destination, .. } => Some(*destination),
|
|
Packet::DmaRemoveTraceReply { destination, .. } => Some(*destination),
|
|
Packet::DmaPlaybackRequest { destination, .. } => Some(*destination),
|
|
Packet::DmaPlaybackReply { destination, .. } => Some(*destination),
|
|
Packet::SubkernelLoadRunRequest { destination, .. } => Some(*destination),
|
|
Packet::SubkernelLoadRunReply { destination, .. } => Some(*destination),
|
|
Packet::SubkernelMessage { destination, .. } => Some(*destination),
|
|
Packet::SubkernelMessageAck { destination } => Some(*destination),
|
|
Packet::DmaPlaybackStatus { destination, .. } => Some(*destination),
|
|
Packet::SubkernelFinished { destination, .. } => Some(*destination),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn expects_response(&self) -> bool {
|
|
// returns true if the routable packet should elicit a response
|
|
// e.g. reply, ACK packets end a conversation,
|
|
// and firmware should not wait for response
|
|
match self {
|
|
Packet::DmaAddTraceReply { .. }
|
|
| Packet::DmaRemoveTraceReply { .. }
|
|
| Packet::DmaPlaybackReply { .. }
|
|
| Packet::SubkernelLoadRunReply { .. }
|
|
| Packet::SubkernelMessageAck { .. }
|
|
| Packet::DmaPlaybackStatus { .. }
|
|
| Packet::SubkernelFinished { .. } => false,
|
|
_ => true,
|
|
}
|
|
}
|
|
}
|