mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-18 08:52:45 +00:00
Merge branch 'main' into tts
This commit is contained in:
commit
a998cf06c4
7 changed files with 1412 additions and 9833 deletions
|
|
@ -354,6 +354,27 @@ def main():
|
||||||
else:
|
else:
|
||||||
patchlen += 1
|
patchlen += 1
|
||||||
|
|
||||||
|
# test to see if we can emit an optimized version of the code
|
||||||
|
is_wellformed = True
|
||||||
|
for frame_rec in patchdata_sorted:
|
||||||
|
frame = frame_rec[1]
|
||||||
|
words_used = [0] * 101
|
||||||
|
for word in range(101):
|
||||||
|
if frame[word] == None:
|
||||||
|
continue
|
||||||
|
words_used[word] = 1
|
||||||
|
if words_used[:32] != [1] * 32:
|
||||||
|
is_wellformed = False
|
||||||
|
if words_used[32:] != [0] * (101-32):
|
||||||
|
is_wellformed = False
|
||||||
|
|
||||||
|
if is_wellformed:
|
||||||
|
print("Patch list is well formed, generating optimized code")
|
||||||
|
generate_optimized(f, patchdata_sorted, patchlen)
|
||||||
|
exit(0)
|
||||||
|
else:
|
||||||
|
print("Patch list is irregular, generating general-case code (is_wellformed: {})".format(is_wellformed))
|
||||||
|
|
||||||
f.write("""
|
f.write("""
|
||||||
//! this file was auto-generated by key2bits.py on {}
|
//! this file was auto-generated by key2bits.py on {}
|
||||||
//! manual regeneration is needed for the following cases:
|
//! manual regeneration is needed for the following cases:
|
||||||
|
|
@ -472,7 +493,9 @@ pub fn should_patch(frame: u32) -> bool {{
|
||||||
}}
|
}}
|
||||||
}}
|
}}
|
||||||
""".format(min(frame_nos), max(frame_nos)))
|
""".format(min(frame_nos), max(frame_nos)))
|
||||||
|
generate_test(f, patchdata_sorted)
|
||||||
|
|
||||||
|
def generate_test(f, patchdata_sorted):
|
||||||
f.write("""
|
f.write("""
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
|
|
@ -501,14 +524,164 @@ mod tests {
|
||||||
bitvalue = (keyrom[coord[0]] & (1 << coord[1]))
|
bitvalue = (keyrom[coord[0]] & (1 << coord[1]))
|
||||||
if bitvalue != 0:
|
if bitvalue != 0:
|
||||||
wordvalue |= (1 << bit)
|
wordvalue |= (1 << bit)
|
||||||
f.write(' assert_eq!(crate::patch_frame({}'.format(frame_rec[0]) + ', ' + '{}'.format(word) + ', &ROM), (Some(' + '0x{:08x}'.format(wordvalue) + '), Some(!0x{:08x}'.format(wordvalue) + ')));\n')
|
f.write(' assert_eq!(crate::key2bits::patch_frame({}'.format(frame_rec[0]) + ', ' + '{}'.format(word) + ', &ROM), Some((' + '0x{:08x}u32'.format(wordvalue) + ', !0x{:08x}u32'.format(wordvalue) + ')));\n')
|
||||||
|
|
||||||
f.write(' // also test the null case, frame 0 should typically have no mappings.\n')
|
f.write(' // also test the null case, frame 0 should typically have no mappings.\n')
|
||||||
f.write(' assert_eq!(crate::patch_frame(0x0, 0, &ROM), (None, None) );\n')
|
f.write(' assert_eq!(crate::key2bits::patch_frame(0x0, 0, &ROM), None );\n')
|
||||||
f.write("""
|
f.write("""
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
""")
|
""")
|
||||||
|
|
||||||
|
def generate_optimized(f, patchdata_sorted, patchlen):
|
||||||
|
sequences = []
|
||||||
|
sequence = []
|
||||||
|
prev_frame = None
|
||||||
|
for frame_rec in patchdata_sorted:
|
||||||
|
if prev_frame == None:
|
||||||
|
prev_frame = frame_rec[0]
|
||||||
|
sequence.append(frame_rec)
|
||||||
|
else:
|
||||||
|
if frame_rec[0] - prev_frame != 1:
|
||||||
|
sequences.append(sequence)
|
||||||
|
sequence = [frame_rec]
|
||||||
|
else:
|
||||||
|
sequence.append(frame_rec)
|
||||||
|
prev_frame = frame_rec[0]
|
||||||
|
sequences.append(sequence)
|
||||||
|
|
||||||
|
# import pprint
|
||||||
|
# pprint.pprint(sequences, indent=6)
|
||||||
|
|
||||||
|
f.write("""
|
||||||
|
//! this file was auto-generated by key2bits.py on {}
|
||||||
|
//! manual regeneration is needed for the following cases:
|
||||||
|
//! - rom.db changes (that is, the KEYROM pcells have been moved to a new location)
|
||||||
|
//! - entirely different FPGA target (in which case, the db/ files also need to be regenerated
|
||||||
|
//! (this is a long process if you're not targting a prjxray pre-build target))
|
||||||
|
//! - bug fixes and enhancements to these routines
|
||||||
|
""".format(str(datetime.now())))
|
||||||
|
|
||||||
|
f.write("""
|
||||||
|
pub const PATCH_FRAMES: [u32; {}] = [\n""".format(len(patchdata_sorted)))
|
||||||
|
for frame_rec in patchdata_sorted:
|
||||||
|
f.write(" 0x{:x},\n".format(frame_rec[0]))
|
||||||
|
f.write("];\n")
|
||||||
|
|
||||||
|
for sequence in sequences:
|
||||||
|
f.write("""
|
||||||
|
const PATCH_TABLE_{}: [u8; {}] = [\n""".format(sequence[0][0], len(sequence) * 2 * 32 * 32))
|
||||||
|
for frame_rec in sequence:
|
||||||
|
f.write(" // frame 0x{:x} ({})".format(frame_rec[0], frame_rec[0]))
|
||||||
|
for bitdict in frame_rec[1]:
|
||||||
|
if bitdict == None:
|
||||||
|
continue
|
||||||
|
for index in range(32):
|
||||||
|
if (index % 16 == 0):
|
||||||
|
f.write("\n ")
|
||||||
|
f.write("{:03},{:03},".format(bitdict[index][0], bitdict[index][1]))
|
||||||
|
f.write("\n")
|
||||||
|
f.write("];\n")
|
||||||
|
|
||||||
|
f.write("""
|
||||||
|
/// patch a frame at a given relative positition and offset in the framestream
|
||||||
|
/// to insert a key ROM.
|
||||||
|
///
|
||||||
|
/// frame is the frame number in the framestream
|
||||||
|
/// offset is the offset in the frame, from 0-100 (101 words)
|
||||||
|
/// note that each primitive in a bitstream is a u32
|
||||||
|
///
|
||||||
|
/// This code path has been optimized because the patch set is well-formed, such that
|
||||||
|
/// the patches are all located in frames 0-31, and are mostly sequential in frames.
|
||||||
|
/// This allows us to use direct array accessors with index operations, instead of a
|
||||||
|
/// more general data structure. This method is less readable, but saves a significant
|
||||||
|
/// amount of code space and reduces compile times. Refer to the generation script
|
||||||
|
/// if a more general form is desired; this option is retained for reference purposes.
|
||||||
|
///
|
||||||
|
/// returns None if the position should not be patched
|
||||||
|
/// returns a tuple of the value and its inverse; this is done to reduce the timing
|
||||||
|
/// sidechannel. The inverse value needs to be consumed to prevent the compiler
|
||||||
|
/// from optimizing out that path.
|
||||||
|
""")
|
||||||
|
|
||||||
|
f.write("""
|
||||||
|
/// a fast check to see if a given frame is within the range of frames that are
|
||||||
|
/// patchable. Use this to wrap calls to `patch_frame` as a performance optimization.
|
||||||
|
pub fn should_patch(frame: u32) -> bool {
|
||||||
|
""")
|
||||||
|
f.write(" if")
|
||||||
|
first_element = True
|
||||||
|
for sequence in sequences:
|
||||||
|
if first_element:
|
||||||
|
f.write(" (frame >= 0x{:x} && frame <= 0x{:x})\n".format(sequence[0][0], sequence[-1][0]))
|
||||||
|
first_element = False
|
||||||
|
else:
|
||||||
|
f.write(" || (frame >= 0x{:x} && frame <= 0x{:x})\n".format(sequence[0][0], sequence[-1][0]))
|
||||||
|
f.write(""" {
|
||||||
|
true
|
||||||
|
} else {
|
||||||
|
false
|
||||||
|
}
|
||||||
|
}""")
|
||||||
|
|
||||||
|
f.write("""
|
||||||
|
fn get_patch_subtable(frame: u32, offset: u32, table_base: u32) -> &'static [u8] {
|
||||||
|
// ASSUME: all offsets are checked before here. Worst case, we throw a panic because of an OOB index.
|
||||||
|
// A frame table consists of:
|
||||||
|
// - 32 patchable words in a frame (it is a convenient coincidence that the
|
||||||
|
// patchable words are at positions 0-31: if the ROM LUTs were implemented
|
||||||
|
// differently, this may not be the case)
|
||||||
|
// - Each word to patch is 32 bits long, thus requiring as many entries
|
||||||
|
// - Each entry consisting of 2 items:
|
||||||
|
// - A u8 address in the conventionally-ordered source key ROM
|
||||||
|
// - A u8 bit position of the data at that address in the same key ROM
|
||||||
|
// Thus a patch table says for a given frame and offset, you may replace the
|
||||||
|
// values with those found at the given address and bit offsets in a key ROM
|
||||||
|
// to program that key ROM into the LUT
|
||||||
|
let base = ((frame - table_base) * 2 * 32 * 32 + (offset * 2 * 32)) as usize;
|
||||||
|
match table_base {
|
||||||
|
""")
|
||||||
|
for sequence in sequences:
|
||||||
|
f.write(" {} => &PATCH_TABLE_{}[base..base + 2 * 32],\n".format(sequence[0][0], sequence[0][0]))
|
||||||
|
f.write(""" _ => panic!("invalid table base in patch.rs")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
""")
|
||||||
|
|
||||||
|
f.write("""
|
||||||
|
pub fn patch_frame(frame: u32, offset: u32, rom: &[u32]) -> Option<(u32, u32)> {
|
||||||
|
if offset >= 32 {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
if should_patch(frame) {
|
||||||
|
// ASSUME: `frame` meets the requirements outlined above
|
||||||
|
let table_base = match frame {
|
||||||
|
""")
|
||||||
|
for sequence in sequences:
|
||||||
|
base = sequence[0][0]
|
||||||
|
for run in sequence:
|
||||||
|
f.write(" {} => {},\n".format(run[0], base))
|
||||||
|
f.write(""" _ => panic!("invalid frame in patch.rs"),
|
||||||
|
};
|
||||||
|
let subtable = get_patch_subtable(frame, offset, table_base);
|
||||||
|
let mut data: u32 = 0;
|
||||||
|
let mut data_inv: u32 = 0;
|
||||||
|
for bit in 0..32 {
|
||||||
|
let (adr, patch_bit) = (subtable[bit * 2], subtable[bit * 2 + 1]);
|
||||||
|
let romval: u32 = rom[adr as usize] & (1 << patch_bit);
|
||||||
|
if romval != 0 {
|
||||||
|
data |= 1 << bit;
|
||||||
|
} else {
|
||||||
|
data_inv |= 1 << bit;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Some((data, data_inv))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
""")
|
||||||
|
generate_test(f, patchdata_sorted)
|
||||||
|
|
||||||
if __name__ == "__main__":
|
if __name__ == "__main__":
|
||||||
main()
|
main()
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -377,8 +377,6 @@ mod bcrypt;
|
||||||
// some short tests to just confirm we're not totally broken.
|
// some short tests to just confirm we're not totally broken.
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn hash_with_fixed_salt() {
|
fn hash_with_fixed_salt() {
|
||||||
let salt: [u8; 16] = [
|
let salt: [u8; 16] = [
|
||||||
|
|
|
||||||
|
|
@ -15,8 +15,14 @@ pub(crate) enum Opcode {
|
||||||
/// force a WDT update
|
/// force a WDT update
|
||||||
PingWdt = 4,
|
PingWdt = 4,
|
||||||
|
|
||||||
/// return the version string of Xous. We bury it here because this is a small, lightweight server we can rebuild on every run.
|
/// Return the version string of Xous. We bury it here because this is a small, lightweight server we can rebuild on every run.
|
||||||
GetVersion = 5,
|
GetVersion = 5,
|
||||||
|
|
||||||
|
/// Lock the given Mutex, blocking if it is already locked
|
||||||
|
LockMutex = 6,
|
||||||
|
|
||||||
|
/// Unlock the given Mutex
|
||||||
|
UnlockMutex = 7,
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
#[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
||||||
|
|
|
||||||
|
|
@ -66,11 +66,61 @@ impl Ticktimer {
|
||||||
version: xous_ipc::String::new(),
|
version: xous_ipc::String::new(),
|
||||||
};
|
};
|
||||||
let mut buf = xous_ipc::Buffer::into_buf(alloc).expect("couldn't convert version request");
|
let mut buf = xous_ipc::Buffer::into_buf(alloc).expect("couldn't convert version request");
|
||||||
buf.lend_mut(self.conn, api::Opcode::GetVersion.to_u32().unwrap()).expect("couldn't get version");
|
buf.lend_mut(self.conn, api::Opcode::GetVersion.to_u32().unwrap())
|
||||||
let v = buf.to_original::<api::VersionString, _>().expect("couldn't revert buffer");
|
.expect("couldn't get version");
|
||||||
|
let v = buf
|
||||||
|
.to_original::<api::VersionString, _>()
|
||||||
|
.expect("couldn't revert buffer");
|
||||||
String::from(v.version.as_str().unwrap())
|
String::from(v.version.as_str().unwrap())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Lock the given Mutex. Blocks until the Mutex is locked.
|
||||||
|
///
|
||||||
|
/// Note that Mutexes start out in a `Locked` state and move into an `Unlocked` state by calling
|
||||||
|
/// `Unlock` on their pointer. For example, the following will probably block forever:
|
||||||
|
///
|
||||||
|
/// `TickTimer.lock_mutex(1)`
|
||||||
|
///
|
||||||
|
/// In order to create a new Mutex, you must first `Unlock` it. For example, the following is
|
||||||
|
/// allowed:
|
||||||
|
///
|
||||||
|
/// `TickTimer.unlock_mutex(1)`
|
||||||
|
/// `TickTimer.lock_mutex(1)`
|
||||||
|
/// `TickTimer.unlock_mutex(1)`
|
||||||
|
///
|
||||||
|
/// Arguments:
|
||||||
|
///
|
||||||
|
/// * mtx: A `usize` referring to the Mutex. This is probably a pointer, but can be any `usize`
|
||||||
|
pub fn lock_mutex(&self, mtx: usize) {
|
||||||
|
send_message(
|
||||||
|
self.conn,
|
||||||
|
xous::Message::new_blocking_scalar(
|
||||||
|
api::Opcode::LockMutex.to_usize().unwrap(),
|
||||||
|
mtx,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
.expect("couldn't lock mutex");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Unlock the given Mutex. Does not block. If the Mutex is not locked, then it will be
|
||||||
|
/// "doubly-unlocked". That is, if you Unlock a mutex twice, then you can Lock it twice
|
||||||
|
/// without blocking.
|
||||||
|
///
|
||||||
|
/// Arguments:
|
||||||
|
///
|
||||||
|
/// * mtx: A `usize` referring to the Mutex. This is probably a pointer, but can be any `usize`
|
||||||
|
pub fn unlock_mutex(&self, mtx: usize) {
|
||||||
|
send_message(
|
||||||
|
self.conn,
|
||||||
|
xous::Message::new_scalar(api::Opcode::UnlockMutex.to_usize().unwrap(), mtx, 0, 0, 0),
|
||||||
|
)
|
||||||
|
.expect("couldn't lock mutex");
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
use core::sync::atomic::{AtomicU32, Ordering};
|
use core::sync::atomic::{AtomicU32, Ordering};
|
||||||
static REFCOUNT: AtomicU32 = AtomicU32::new(0);
|
static REFCOUNT: AtomicU32 = AtomicU32::new(0);
|
||||||
impl Drop for Ticktimer {
|
impl Drop for Ticktimer {
|
||||||
|
|
|
||||||
|
|
@ -475,7 +475,7 @@ fn xmain() -> ! {
|
||||||
|
|
||||||
log::info!("****************************************************************");
|
log::info!("****************************************************************");
|
||||||
log::info!("Welcome to Xous {}", version::SEMVER);
|
log::info!("Welcome to Xous {}", version::SEMVER);
|
||||||
#[cfg(not(feature="no-timestamp"))]
|
#[cfg(not(feature = "no-timestamp"))]
|
||||||
log::info!("Built on {}", version::TIMESTAMP);
|
log::info!("Built on {}", version::TIMESTAMP);
|
||||||
log::info!("****************************************************************");
|
log::info!("****************************************************************");
|
||||||
|
|
||||||
|
|
@ -495,8 +495,27 @@ fn xmain() -> ! {
|
||||||
let xns = xous_names::XousNames::new().unwrap();
|
let xns = xous_names::XousNames::new().unwrap();
|
||||||
let sr_cid =
|
let sr_cid =
|
||||||
xous::connect(ticktimer_server).expect("couldn't create suspend callback connection");
|
xous::connect(ticktimer_server).expect("couldn't create suspend callback connection");
|
||||||
let mut susres = susres::Susres::new(Some(SuspendOrder::Last), &xns, api::Opcode::SuspendResume as u32, sr_cid)
|
let mut susres = susres::Susres::new(
|
||||||
.expect("couldn't create suspend/resume object");
|
Some(SuspendOrder::Last),
|
||||||
|
&xns,
|
||||||
|
api::Opcode::SuspendResume as u32,
|
||||||
|
sr_cid,
|
||||||
|
)
|
||||||
|
.expect("couldn't create suspend/resume object");
|
||||||
|
|
||||||
|
use std::collections::{HashMap, HashSet, VecDeque};
|
||||||
|
|
||||||
|
// A list of mutexes that should be allowed to run immediately, because the
|
||||||
|
// thread they were waiting on has already unlocked the mutex. This occurs
|
||||||
|
// when a thread attempts to Lock a Mutex and fails, then gets preempted
|
||||||
|
// before it has a chance to send the `LockMutex` message to us.
|
||||||
|
let mut mutex_ready_hash: HashMap<Option<xous::PID>, HashSet<usize>> = HashMap::new();
|
||||||
|
|
||||||
|
// A list of message IDs that are waiting to lock a Mutex. These are processes
|
||||||
|
// that have attempted to lock a Mutex and failed, and have sent us the `LockMutex`
|
||||||
|
// message. This queue is drained by threads sending `UnlockMutex` to us.
|
||||||
|
let mut mutex_hash: HashMap<Option<xous::PID>, HashMap<usize, VecDeque<xous::MessageSender>>> =
|
||||||
|
HashMap::new();
|
||||||
|
|
||||||
loop {
|
loop {
|
||||||
#[cfg(feature = "watchdog")]
|
#[cfg(feature = "watchdog")]
|
||||||
|
|
@ -540,9 +559,60 @@ fn xmain() -> ! {
|
||||||
ticktimer.reset_wdt();
|
ticktimer.reset_wdt();
|
||||||
}
|
}
|
||||||
Some(api::Opcode::GetVersion) => {
|
Some(api::Opcode::GetVersion) => {
|
||||||
let mut buf = unsafe{xous_ipc::Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
|
let mut buf = unsafe {
|
||||||
|
xous_ipc::Buffer::from_memory_message_mut(
|
||||||
|
msg.body.memory_message_mut().unwrap(),
|
||||||
|
)
|
||||||
|
};
|
||||||
buf.replace(version::get_version()).unwrap();
|
buf.replace(version::get_version()).unwrap();
|
||||||
}
|
}
|
||||||
|
Some(api::Opcode::LockMutex) => {
|
||||||
|
let pid = msg.sender.pid();
|
||||||
|
if !msg.body.is_blocking() {
|
||||||
|
info!("sender made LockMutex request that was not blocking");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if let Some(scalar) = msg.body.scalar_message() {
|
||||||
|
let ready = mutex_ready_hash.entry(pid).or_default();
|
||||||
|
|
||||||
|
// If this item is in the Ready list, return right away without blocking
|
||||||
|
if ready.remove(&scalar.arg1) {
|
||||||
|
xous::return_scalar(msg.sender, 0).unwrap();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// This item is not in the Ready list, so add our sender to the list of processes
|
||||||
|
// to get called when UnlockMutex is invoked
|
||||||
|
let awaiting = mutex_hash.entry(pid).or_default();
|
||||||
|
|
||||||
|
// Add this to the end of the list of entries to call so that when `UnlockMutex` is sent
|
||||||
|
// the message will get a response.
|
||||||
|
let mutex_entry = awaiting.entry(scalar.arg1).or_default();
|
||||||
|
mutex_entry.push_back(msg.sender);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Some(api::Opcode::UnlockMutex) => {
|
||||||
|
let pid = msg.sender.pid();
|
||||||
|
if msg.body.is_blocking() {
|
||||||
|
info!("sender made UnlockMutex request that was blocking");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if let Some(scalar) = msg.body.scalar_message() {
|
||||||
|
// Get a list of awaiting mutexes for this process
|
||||||
|
let awaiting = mutex_hash.entry(pid).or_default();
|
||||||
|
|
||||||
|
// Get the vector of awaiting mutex entries.
|
||||||
|
let mutex_entry = awaiting.entry(scalar.arg1).or_default();
|
||||||
|
|
||||||
|
// If there's something waiting in the queue, respond to that message
|
||||||
|
if let Some(sender) = mutex_entry.pop_front() {
|
||||||
|
xous::return_scalar(sender, 0).unwrap();
|
||||||
|
} else {
|
||||||
|
// Otherwise, mark this scalar as being ready to run
|
||||||
|
mutex_ready_hash.entry(pid).or_default().insert(scalar.arg1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
None => {
|
None => {
|
||||||
error!("couldn't convert opcode");
|
error!("couldn't convert opcode");
|
||||||
break;
|
break;
|
||||||
|
|
|
||||||
|
|
@ -57,7 +57,7 @@ pub static TESTING_RNG_SEED: AtomicU64 = AtomicU64::new(0);
|
||||||
pub mod exceptions;
|
pub mod exceptions;
|
||||||
pub use exceptions::*;
|
pub use exceptions::*;
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Copy, Clone)]
|
#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Copy, Clone, Default)]
|
||||||
pub struct MessageSender {
|
pub struct MessageSender {
|
||||||
data: usize,
|
data: usize,
|
||||||
}
|
}
|
||||||
|
|
@ -77,12 +77,6 @@ impl MessageSender {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl core::default::Default for MessageSender {
|
|
||||||
fn default() -> Self {
|
|
||||||
MessageSender { data: 0 }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl core::fmt::Display for MessageSender {
|
impl core::fmt::Display for MessageSender {
|
||||||
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
||||||
write!(f, "MessageSender.data: 0x{:08x}", self.data)
|
write!(f, "MessageSender.data: 0x{:08x}", self.data)
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue