Merge branch 'fix-messages'

This commit is contained in:
Sean Cross 2021-03-23 21:58:11 +08:00
commit e894dbd7b8
31 changed files with 1416 additions and 955 deletions

17
Cargo.lock generated
View file

@ -602,6 +602,9 @@ checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
name = "kernel-test"
version = "0.1.0"
dependencies = [
"log",
"log-server",
"ticktimer-server",
"utralib",
"xous",
]
@ -1072,6 +1075,20 @@ dependencies = [
"syn 1.0.60",
]
[[package]]
name = "rtc"
version = "0.1.0"
dependencies = [
"bitflags",
"heapless",
"log",
"log-server",
"ticktimer-server",
"utralib",
"xous",
"xous-names",
]
[[package]]
name = "rustc-hash"
version = "1.1.0"

View file

@ -27,6 +27,7 @@ members = [
"services/ime-plugin-api",
"services/content-plugin-api",
"services/llio",
"services/rtc",
"services/trng-tester",
]
default-members = [
@ -50,6 +51,7 @@ default-members = [
"services/content-plugin-api",
"services/shellchat",
"services/llio",
"services/rtc",
"services/trng-tester",
]

View file

@ -47,12 +47,16 @@ namespace Antmicro.Renode.Peripherals.Timers
private void UpdateInterrupts()
{
if (this.irqStatus && this.irqEnabled.Value)
if ((Interlocked.Read(ref this.tickValue) >= (long)this.msleepTarget) && this.irqEnabled.Value)
{
this.irqPending.Value = true;
}
this.Log(LogLevel.Noisy, "Setting IRQ: {0}", irqPending.Value);
IRQ.Set(irqPending.Value && irqEnabled.Value);
this.Log(LogLevel.Noisy, "Setting IRQ: {0} because tickValue {1} >= msleepTarget {2} ({3}) and irqEnabled = {4}",
irqPending.Value && this.irqEnabled.Value,
this.tickValue,
this.msleepTarget,
this.tickValue >= (long)this.msleepTarget, this.irqEnabled.Value);
IRQ.Set(this.irqPending.Value && this.irqEnabled.Value);
}
public long Size { get { return 0x20; } }
@ -88,7 +92,7 @@ namespace Antmicro.Renode.Peripherals.Timers
.WithValueField(0, 32, name: "MsleepTarget1", writeCallback: (_, value) =>
{
this.msleepTarget = (this.msleepTarget & 0x00000000ffffffff) | (value << 32);
this.Log(LogLevel.Noisy, "Setting sleep target 1: {0}, sleep target now: {1}", value, this.msleepTarget);
this.Log(LogLevel.Noisy, "Setting MsleepTarget1: {0}, sleep target now: {1}", value, this.msleepTarget);
},
valueProviderCallback: _ =>
{
@ -101,7 +105,7 @@ namespace Antmicro.Renode.Peripherals.Timers
writeCallback: (_, value) =>
{
this.msleepTarget = (this.msleepTarget & 0xffffffff00000000) | (value & 0xffffffff);
this.Log(LogLevel.Noisy, "Setting sleep target 0: {0}, sleep target now: {1}", value, this.msleepTarget);
this.Log(LogLevel.Noisy, "Setting MsleepTarget0: {0}, sleep target now: {1}", value, this.msleepTarget);
},
valueProviderCallback: _ =>
{

View file

@ -22,10 +22,11 @@ machine LoadPlatformDescription @betrusted.repl
machine StartGdbServer 3333 true
showAnalyzer uart
showAnalyzer uartconsole
showAnalyzer uartserver0
showAnalyzer memlcd
# showAnalyzer uartserver0
# showAnalyzer memlcd
logLevel -1 kbd
# logLevel -1 ticktimer
# The macro `reset` gets called implicitly when running `machine Reset`
macro reset

View file

@ -21,6 +21,7 @@ riscv = "0.5.6"
debug-print = []
print-panics = []
report-memory = ["stats_alloc"]
wrap-print = []
#default = ["print-panics", "debug-print"]
default = ["print-panics"]

View file

@ -443,6 +443,7 @@ pub fn idle() -> bool {
};
let pid1 = SystemServices::with_mut(|ss| ss.create_process(pid1_init)).unwrap();
assert_eq!(pid1.get(), 1);
let _tid1 = SystemServices::with_mut(|ss| ss.create_thread(pid1, ThreadInit {})).unwrap();
let listen_addr = env::var("XOUS_LISTEN_ADDR")
.map(|s| {

View file

@ -3,14 +3,6 @@
use xous_kernel::{TID, PID};
pub fn disable_all_irqs() {
// There are no IRQs in a hosted environment, so there's nothing to do.
}
pub fn enable_all_irqs() {
// There are no IRQs in a hosted environment, so there's nothing to do.
}
pub fn enable_irq(_irq_no: usize) {
unimplemented!();
}

View file

@ -19,7 +19,6 @@ pub fn current_pid() -> PID {
pub fn init() {
unsafe {
sstatus::set_sie();
sie::set_ssoft();
sie::set_sext();
}
@ -29,6 +28,21 @@ pub fn init() {
/// Put the core to sleep until an interrupt hits. Returns `true`
/// to indicate the kernel should not exit.
pub fn idle() -> bool {
// Issue `wfi`. This will return as soon as an external interrupt
// is available.
unsafe { riscv::asm::wfi() };
// Enable interrupts temporarily in Supervisor mode, allowing them
// to drain. Aside from this brief instance, interrupts are
// disabled when running in Supervisor mode.
//
// These interrupts are handled by userspace, so code execution will
// immediately jump to the interrupt handler and return here after
// all interrupts have been handled.
unsafe {
sstatus::set_sie();
sstatus::clear_sie();
};
true
}

View file

@ -6,9 +6,6 @@ use core::fmt::{Error, Write};
#[cfg(baremetal)]
use utralib::generated::*;
#[allow(dead_code)] // this is unused in hosted mode, kill the warning
static mut INITIALIZED: bool = false;
#[macro_use]
#[cfg(all(
not(test),
@ -66,6 +63,11 @@ macro_rules! println
pub struct Uart {
// pub base: *mut usize,
}
#[cfg(baremetal)]
static mut INITIALIZED: bool = false;
#[cfg(all(baremetal, feature = "wrap-print"))]
static mut CHAR_COUNT: usize = 0;
#[cfg(baremetal)]
impl Uart {
@ -86,6 +88,23 @@ impl Uart {
while uart_csr.r(utra::uart::TXFULL) != 0 {
()
}
#[cfg(feature = "wrap-print")]
unsafe {
if c == b'\n' {
CHAR_COUNT = 0;
} else if CHAR_COUNT > 80 {
CHAR_COUNT = 0;
self.putc(b'\n');
self.putc(b'\r');
self.putc(b' ');
self.putc(b' ');
self.putc(b' ');
self.putc(b' ');
}
else {
CHAR_COUNT += 1;
}
}
uart_csr.wfo(utra::uart::RXTX_RXTX, c as u32);
}

View file

@ -53,7 +53,6 @@ pub fn interrupt_claim(
// Unsafe is required since we're accessing a static mut array.
// However, we disable interrupts to prevent contention on this array.
unsafe {
arch::irq::disable_all_irqs();
let result = if irq > IRQ_HANDLERS.len() {
Err(xous_kernel::Error::InterruptNotFound)
} else if IRQ_HANDLERS[irq].is_some() {
@ -63,7 +62,6 @@ pub fn interrupt_claim(
arch::irq::enable_irq(irq);
Ok(())
};
arch::irq::enable_all_irqs();
result
}
}

View file

@ -153,9 +153,7 @@ pub extern "C" fn kmain() {
}
loop {
arch::irq::disable_all_irqs();
pid = next_pid_to_run(pid);
arch::irq::enable_all_irqs();
match pid {
Some(pid) => {
@ -170,8 +168,10 @@ pub extern "C" fn kmain() {
#[cfg(feature = "debug-print")]
SystemServices::with(|system_services| {
for test_idx in 0..system_services.processes.len() {
println!("{:?}", system_services.processes[test_idx]);
for (test_idx, process) in system_services.processes.iter().enumerate() {
if ! process.free() {
println!("PID {}: {:?}", test_idx + 1, process);
}
}
});

View file

@ -387,17 +387,26 @@ impl Server {
}
}
*current_val = QueuedMessage::Empty;
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
if idx == self.queue_tail {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
// Advance the pointer in case we have a long string of Empty messages.
while self.queue_tail != self.queue_head && self.queue[self.queue_tail] == QueuedMessage::Empty {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
}
}
// Destructure the PID and context ID from the `pid_tid` field
klog!(
"taking waiting message and returning to pid: {} tid: {}",
pid,
tid
);
// klog!(
// "taking waiting message and returning to pid: {} tid: {}",
// pid,
// tid
// );
if !is_memory {
return Ok(WaitingMessage::ScalarMessage(
@ -442,219 +451,259 @@ impl Server {
/// * **None**: There are no waiting messages
/// ***Some(MessageEnvelope): This message is queued.
pub fn take_next_message(&mut self, sidx: usize) -> Option<xous_kernel::MessageEnvelope> {
// println!(
// klog!(
// "queue_head: ((({}))) queue_tail: ((({}))): {:?} CID: ((({})))",
// self.queue_head, self.queue_tail, self.queue[self.queue_tail], sidx
// self.queue_head,
// self.queue_tail,
// self.queue[self.queue_tail],
// sidx
// );
use core::convert::TryInto;
let mut sender = SenderID::new(sidx, self.queue_tail, None);
let (result, response) = match self.queue[self.queue_tail] {
QueuedMessage::Empty => return None,
QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => return None,
QueuedMessage::WaitingForget(_, _, _, _, _) => return None,
QueuedMessage::WaitingReturnScalar(_, _, _) => return None,
QueuedMessage::MemoryMessageROLend(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::MemoryMessageRWLend(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::MemoryMessageROLendTerminated(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::MemoryMessageRWLendTerminated(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
let mut queue_idx = self.queue_tail;
while queue_idx != self.queue_head {
let mut sender = SenderID::new(sidx, queue_idx, None);
// klog!("Message @ server.queue[{}]: {:?}", queue_idx, self.queue[queue_idx]);
let (result, response) = match self.queue[queue_idx] {
QueuedMessage::Empty => {
queue_idx += 1;
if queue_idx >= self.queue.len() {
queue_idx = 0;
}
continue;
}
QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => {
queue_idx += 1;
if queue_idx >= self.queue.len() {
queue_idx = 0;
}
continue;
}
QueuedMessage::WaitingForget(_, _, _, _, _) => {
queue_idx += 1;
if queue_idx >= self.queue.len() {
queue_idx = 0;
}
continue;
}
QueuedMessage::WaitingReturnScalar(_, _, _) => {
queue_idx += 1;
if queue_idx >= self.queue.len() {
queue_idx = 0;
}
continue;
}
QueuedMessage::MemoryMessageROLend(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::MemoryMessageRWLend(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::MemoryMessageROLendTerminated(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::MemoryMessageRWLendTerminated(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::BlockingScalarMessage(
pid,
tid,
client_addr,
id,
arg1,
arg2,
arg3,
arg4,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
QueuedMessage::BlockingScalarMessage(
pid,
tid,
client_addr,
id,
arg1,
arg2,
arg3,
arg4,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::BlockingScalar(
xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
},
),
},
QueuedMessage::WaitingReturnScalar(pid, tid, client_addr),
)
}
QueuedMessage::MemoryMessageSend(
pid,
_tid,
_reserved,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage {
body: xous_kernel::Message::Move(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
};
self.queue[queue_idx] = QueuedMessage::Empty;
if queue_idx == self.queue_tail {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
}
return Some(msg);
}
// Scalar messages have nothing to return, so they can go straight to the `Free` state
QueuedMessage::ScalarMessage(pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
}),
},
QueuedMessage::WaitingReturnScalar(pid, tid, client_addr),
)
}
QueuedMessage::MemoryMessageSend(
pid,
_tid,
_reserved,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Move(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
};
self.queue[self.queue_tail] = QueuedMessage::Empty;
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
};
self.queue[queue_idx] = QueuedMessage::Empty;
if queue_idx == self.queue_tail {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
}
return Some(msg);
}
return Some(msg);
}
QueuedMessage::BlockingScalarTerminated(
pid,
_tid,
_reserved,
id,
arg1,
arg2,
arg3,
arg4,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
}),
};
self.queue[queue_idx] = QueuedMessage::Empty;
if queue_idx == self.queue_tail {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
}
return Some(msg);
}
};
// Scalar messages have nothing to return, so they can go straight to the `Free` state
QueuedMessage::ScalarMessage(pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
}),
};
self.queue[self.queue_tail] = QueuedMessage::Empty;
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
return Some(msg);
}
QueuedMessage::BlockingScalarTerminated(
pid,
_tid,
_reserved,
id,
arg1,
arg2,
arg3,
arg4,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
}),
};
self.queue[self.queue_tail] = QueuedMessage::Empty;
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
return Some(msg);
}
};
self.queue[self.queue_tail] = response;
Some(result)
self.queue[queue_idx] = response;
return Some(result);
}
None
}
/// Add the given message to this server's queue.
@ -669,7 +718,12 @@ impl Server {
message: xous_kernel::Message,
original_address: Option<MemoryAddress>,
) -> core::result::Result<usize, xous_kernel::Error> {
// println!("Queueing message: {:?} for pid: {} tid: {}", message, pid.get(), context);
// klog!(
// "Queueing message: {:?} for pid: {} tid: {}",
// message,
// pid.get(),
// context
// );
if self.queue[self.queue_head] != QueuedMessage::Empty {
return Err(xous_kernel::Error::ServerQueueFull);
}
@ -732,6 +786,11 @@ impl Server {
if self.queue_head >= self.queue.len() {
self.queue_head = 0;
}
// klog!(
// "queue head: {} queue_tail: {}",
// self.queue_head,
// self.queue_tail
// );
Ok(idx)
}

View file

@ -717,7 +717,7 @@ impl SystemServices {
/// If the current process is not running.
pub fn switch_from_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> {
let process = self.get_process_mut(pid)?;
// println!(
// klog!(
// "switch_from_thread({}:{}): Old state was {:?}",
// pid, tid, process.state
// );
@ -750,7 +750,7 @@ impl SystemServices {
);
},
};
// println!(
// klog!(
// "switch_from_thread({}:{}): New state is {:?}",
// pid, tid, process.state
// );
@ -810,14 +810,12 @@ impl SystemServices {
) -> Result<TID, xous_kernel::Error> {
let previous_pid = self.current_pid();
let debug = false;
if debug {
println!(
"\n\r KERNEL({},{}): Activating process {} thread {}",
previous_pid, previous_tid, new_pid, new_tid
);
//ArchProcess::with_current(|current| current.print_thread());
if new_tid != 0 {
klog!("Activating process {} thread {}", new_pid, new_tid);
} else {
klog!("Activating process {} thread ANY", new_pid);
}
//ArchProcess::with_current(|current| current.print_thread());
// Save state if the PID has changed. This will activate the new memory
// space.
@ -854,13 +852,15 @@ impl SystemServices {
}
}
new.current_thread = new_tid as _;
// println!(" -- picked thread {}", new_tid);
klog!("picked thread ID {}", new_tid);
} else if x & (1 << new_tid) == 0 {
// println!(
// "thread is {:?}, which is not valid for new thread {}",
// new.state, new_tid
// );
return Err(xous_kernel::Error::ProcessNotFound);
} else {
new.current_thread = new_tid as _;
}
}
ProcessState::Sleeping => {
@ -874,8 +874,8 @@ impl SystemServices {
// if we encounter an error.
new.mapping.activate()?;
// Set up the new process, if necessary. Remove the new context from
// the list of ready contexts.
// Set up the new process, if necessary. Remove the new thread from
// the list of ready threads.
new.state = match new.state {
ProcessState::Setup(thread_init) => {
// println!("Setting up new process...");
@ -902,14 +902,16 @@ impl SystemServices {
let previous = self
.get_process_mut(previous_pid)
.expect("couldn't get previous pid");
let _oldstate = previous.state; // for tracking state in the debug print after the following closure
let _oldstate = previous.state; // for tracking state in the debug print after the following closure
previous.state = match previous.state {
// If the previous process had exactly one thread that can be
// run, then the Running thread list will be 0. In that case,
// we will either need to Sleep this process, or mark it as
// being Ready to run.
ProcessState::Running(x) if x == 0 => {
if can_resume /*|| advance_thread*/ {
if can_resume
/*|| advance_thread*/
{
ProcessState::Ready(1 << previous_tid)
} else {
ProcessState::Sleeping
@ -930,17 +932,18 @@ impl SystemServices {
previous_pid, other
),
};
if debug {println!(" KERNEL|STATE: state change from {:?} -> {:?}", _oldstate, previous.state);}
// if advance_thread {
// previous.current_thread += 1;
// if previous.current_thread as TID > arch::process::MAX_CONTEXT {
// previous.current_thread = 0;
// }
// }
// println!(
// "Set previous process PID {} state to {:?} (with can_resume = {})",
// previous_pid, previous.state, can_resume
// );
klog!(
"PID {:?} state change from {:?} -> {:?}",
previous_pid,
_oldstate,
previous.state
);
// klog!(
// "Set previous process PID {} state to {:?} (with can_resume = {})",
// previous_pid,
// previous.state,
// can_resume
// );
} else {
let new = self.get_process_mut(new_pid)?;
@ -976,7 +979,9 @@ impl SystemServices {
}
// Mark the previous TID as being runnable, and remove the new TID
// from the list of threads that can be run.
ProcessState::Running(x & !(1 << new_tid) | if can_resume { 1 << previous_tid } else { 0 })
ProcessState::Running(
x & !(1 << new_tid) | if can_resume { 1 << previous_tid } else { 0 },
)
} else {
panic!(
"PID {} invalid process state (not Running): {:?}",
@ -1390,23 +1395,34 @@ impl SystemServices {
/// queue.
/// * **ServerNotFound**: The server queue was full and a free slot could not
/// be found.
pub fn create_server(
&mut self,
pid: PID,
) -> Result<(SID, CID), xous_kernel::Error> {
let sid = SID::from_u32(arch::rand::get_u32(), arch::rand::get_u32(), arch::rand::get_u32(), arch::rand::get_u32());
pub fn create_server(&mut self, pid: PID) -> Result<(SID, CID), xous_kernel::Error> {
let sid = SID::from_u32(
arch::rand::get_u32(),
arch::rand::get_u32(),
arch::rand::get_u32(),
arch::rand::get_u32(),
);
self.create_server_with_address(pid, sid)
}
/// Generate a random server ID and return it to the caller. Doesn't create
/// any processes.
pub fn create_server_id(&mut self) -> Result<SID, xous_kernel::Error> {
let sid = SID::from_u32(arch::rand::get_u32(), arch::rand::get_u32(), arch::rand::get_u32(), arch::rand::get_u32());
let sid = SID::from_u32(
arch::rand::get_u32(),
arch::rand::get_u32(),
arch::rand::get_u32(),
arch::rand::get_u32(),
);
Ok(sid)
}
/// Connect to a server on behalf of another process.
pub fn connect_process_to_server(&mut self, target_pid: PID, sid: SID) -> Result<CID, xous_kernel::Error>{
pub fn connect_process_to_server(
&mut self,
target_pid: PID,
sid: SID,
) -> Result<CID, xous_kernel::Error> {
let original_pid = crate::arch::process::current_pid();
let process = self.get_process_mut(target_pid)?;

View file

@ -64,7 +64,6 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
let sidx = ss
.sidx_from_cid(cid)
.ok_or(xous_kernel::Error::ServerNotFound)?;
// ::debug_here::debug_here!();
let server_pid = ss
.server_from_sidx(sidx)
@ -140,20 +139,21 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
}
};
// If the server has an available context to receive the message,
// If the server has an available thread to receive the message,
// transfer it right away.
if let Some(server_tid) = ss
.server_from_sidx_mut(sidx)
.expect("server couldn't be located")
.take_available_thread()
{
klog!(
"there are contexts available to handle this message -- marking PID {} as Ready",
server_pid
);
// klog!(
// "there are threads available in PID {} to handle this message -- marking as Ready",
// server_pid
// );
let sender_idx = if message.is_blocking() {
ss.remember_server_message(sidx, pid, thread, &message, client_address)
.map_err(|e| {
klog!("error remembering server message: {:?}", e);
ss.server_from_sidx_mut(sidx)
.expect("server couldn't be located")
.return_available_thread(thread);
@ -184,12 +184,12 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
})?;
if blocking && cfg!(baremetal) {
// println!("Activating Server context and switching away from Client");
klog!("Activating Server context and switching away from Client");
ss.activate_process_thread(thread, server_pid, server_tid, !blocking)
.map(|_| Ok(xous_kernel::Result::Message(envelope)))
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} else if blocking && !cfg!(baremetal) {
// println!("Blocking client, since it sent a blocking message");
klog!("Blocking client, since it sent a blocking message");
ss.switch_from_thread(pid, thread)?;
ss.switch_to_thread(server_pid, Some(server_tid))?;
ss.set_thread_result(
@ -199,7 +199,8 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
)
.map(|_| xous_kernel::Result::BlockedProcess)
} else if cfg!(baremetal) {
// println!("Setting the return value of the Server and returning to Client");
klog!("Setting the return value of the Server ({}:{}) to {:?} and returning to Client",
server_pid, server_tid, envelope);
ss.set_thread_result(
server_pid,
server_tid,
@ -223,7 +224,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
}
} else {
klog!(
"no threads available in PID {} to handle this message, so blocking",
"no threads available in PID {} to handle this message, so queueing",
server_pid
);
// Add this message to the queue. If the queue is full, this
@ -734,15 +735,21 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
Ok(xous_kernel::Result::ResumeProcess)
}
SysCall::ReceiveMessage(sid) => receive_message(pid, tid, sid, ExecutionType::Blocking),
SysCall::TryReceiveMessage(sid) => receive_message(pid, tid, sid, ExecutionType::NonBlocking),
SysCall::TryReceiveMessage(sid) => {
receive_message(pid, tid, sid, ExecutionType::NonBlocking)
}
SysCall::WaitEvent => SystemServices::with_mut(|ss| {
let process = ss.get_process(pid).expect("Can't get current process");
let ppid = process.ppid;
unsafe { SWITCHTO_CALLER = None };
// TODO: Advance thread
ss.activate_process_thread(tid, ppid, 0, false)
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
if cfg!(baremetal) {
ss.activate_process_thread(tid, ppid, 0, false)
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} else {
Ok(xous_kernel::Result::Ok)
}
}),
SysCall::CreateThread(thread_init) => SystemServices::with_mut(|ss| {
ss.create_thread(pid, thread_init).map(|new_tid| {
@ -767,7 +774,7 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
}),
SysCall::CreateServerId => SystemServices::with_mut(|ss| {
ss.create_server_id()
.map(|sid| xous_kernel::Result::ServerID(sid))
.map(|sid| xous_kernel::Result::ServerID(sid))
}),
SysCall::TryConnect(sid) => SystemServices::with_mut(|ss| {
ss.connect_to_server(sid)
@ -792,12 +799,8 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
SysCall::Shutdown => {
SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok))
}
SysCall::GetProcessId => {
Ok(xous_kernel::Result::ProcessID(pid))
}
SysCall::GetThreadId => {
Ok(xous_kernel::Result::ThreadID(tid))
}
SysCall::GetProcessId => Ok(xous_kernel::Result::ProcessID(pid)),
SysCall::GetThreadId => Ok(xous_kernel::Result::ThreadID(tid)),
SysCall::Connect(sid) => {
let result = SystemServices::with_mut(|ss| {

View file

@ -181,7 +181,7 @@ impl ModalCanvases {
#[xous::xous_main]
fn xmain() -> ! {
let debug1 = false; // debug level 1 - most general level
let debugc = false;
let debugc = true;
log_server::init_wait().unwrap();
info!("GAM: my PID is {}", xous::process::id());
@ -230,222 +230,211 @@ fn xmain() -> ! {
let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
info!("GAM: entering main loop");
loop {
let maybe_env = xous::try_receive_message(gam_sid).unwrap();
if debug1 { if maybe_env.is_some() {info!("GAM: Message: {:?}", maybe_env);} }
match maybe_env {
Some(envelope) => {
if debug1 {info!("GAM: Message: {:?}", envelope); }
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
if debug1 {info!("GAM: Opcode: {:?}", opcode);}
match opcode {
Opcode::ClearCanvas(gid) => {
match canvases.get(&gid) {
Some(c) => {
let mut rect = c.clip_rect();
rect.style = DrawStyle {fill_color: Some(PixelColor::Light), stroke_color: None, stroke_width: 0,};
graphics_server::draw_rectangle(gfx_conn, rect).expect("GAM: can't clear canvas");
},
None => info!("GAM: attempt to clear bogus canvas, ignored."),
}
let envelope = xous::receive_message(gam_sid).unwrap();
if debug1 { info!("GAM: Message: {:?}", envelope);}
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
if debug1 {info!("GAM: Opcode: {:?}", opcode);}
match opcode {
Opcode::ClearCanvas(gid) => {
match canvases.get(&gid) {
Some(c) => {
let mut rect = c.clip_rect();
rect.style = DrawStyle {fill_color: Some(PixelColor::Light), stroke_color: None, stroke_width: 0,};
graphics_server::draw_rectangle(gfx_conn, rect).expect("GAM: can't clear canvas");
},
Opcode::GetCanvasBounds(gid) => {
match canvases.get(&gid) {
Some(c) => {
let mut rect = c.clip_rect();
rect.normalize(); // normalize to 0,0 coordinates
xous::return_scalar2(envelope.sender,
rect.tl.into(),
rect.br.into(),
).expect("GAM: couldn't return canvas bounds");
},
None => info!("GAM: attempt to get bounds on bogus canvas gid {:?}, {:?} ignored.", gid, envelope),
}
},
Opcode::PowerDownRequest => {
powerdown_requested = true;
graphics_server::draw_sleepscreen(gfx_conn).expect("GAM: couldn't draw sleep screen");
// a screen flush is part of the draw_sleepscreen abstraction
xous::return_scalar(envelope.sender, 1).expect("GAM: couldn't confirm power down UI request");
},
Opcode::Redraw => {
if powerdown_requested {
continue; // don't allow any redraws if a powerdown is requested
}
if let Ok(elapsed_time) = ticktimer_server::elapsed_ms(ticktimer_conn) {
if elapsed_time - last_time > 33 { // rate limit updates, no point in going faster than the eye can see
last_time = elapsed_time;
deface(gfx_conn, &mut canvases);
graphics_server::flush(gfx_conn).expect("GAM: couldn't flush buffer to screen");
/* // this throws errors right now because deface() doesn't work.
for (_, c) in canvases.iter_mut() {
c.do_flushed();
}*/
}
}
},
_ => todo!("GAM: opcode not yet implemented"),
None => info!("GAM: attempt to clear bogus canvas, ignored."),
}
} else if let xous::Message::MutableBorrow(m) = &envelope.body {
let mut buf = unsafe { xous::XousBuffer::from_memory_message(m) };
let value = unsafe {
archived_value_mut::<api::Opcode>(Pin::new(buf.as_mut()), m.id as usize)
};
match &*value {
rkyv::Archived::<api::Opcode>::RenderTextView(rtv) => {
let mut tv = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: rendertextview {:?}", tv);}
match tv.get_op() {
TextOp::Nop => (),
TextOp::Render | TextOp::ComputeBounds => {
if debug1{info!("GAM: render request for {:?}", tv);}
if tv.get_op() == TextOp::ComputeBounds {
tv.dry_run = true;
} else {
tv.dry_run = false;
}
if let Some(canvas) = canvases.get_mut(&tv.get_canvas_gid()) {
// first, figure out if we should even be drawing to this canvas.
if canvas.is_drawable() {
// set the clip rectangle according to the canvas' location
tv.clip_rect = Some(canvas.clip_rect().into());
// you have to clone the tv object, because if you don't the same block of
// memory gets passed on to the graphics_server(). Which is efficient, but,
// the call will automatically Drop() the memory, which causes a panic when
// this routine returns.
let mut tv_clone = tv.clone();
// issue the draw command
graphics_server::draw_textview(gfx_conn, &mut tv_clone).expect("GAM: text view draw could not complete.");
// copy back the fields that we want to be mutable
if debug1{info!("GAM: got computed cursor of {:?}", tv_clone.cursor);}
tv.cursor = tv_clone.cursor;
tv.bounds_computed = tv_clone.bounds_computed;
// pack our data back into the buffer to return
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::RenderTextView(tv)).expect("GAM: couldn't re-archive return value");
canvas.do_drawn().expect("GAM: couldn't set canvas to drawn");
} else {
info!("GAM: attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored.");
}
} else {
info!("GAM: bogus GID {:?} in TextView {}, not doing anything in response to draw request.", tv.get_canvas_gid(), tv.text);
// silently fail if a bogus Gid is given???
}
},
};
},
Opcode::GetCanvasBounds(gid) => {
match canvases.get(&gid) {
Some(c) => {
let mut rect = c.clip_rect();
rect.normalize(); // normalize to 0,0 coordinates
xous::return_scalar2(envelope.sender,
rect.tl.into(),
rect.br.into(),
).expect("GAM: couldn't return canvas bounds");
},
rkyv::Archived::<api::Opcode>::SetCanvasBounds(rcb) => {
let mut cb: SetCanvasBoundsRequest = rcb.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: SetCanvasBoundsRequest {:?}", cb);}
// ASSUME:
// very few canvases allow dynamic resizing, so we special case these
if cb.canvas == chatlayout.input {
let newheight = chatlayout.resize_input(cb.requested.y, &mut canvases).expect("GAM: SetCanvasBoundsRequest couldn't recompute input canvas height");
cb.granted = Some(newheight);
canvases = recompute_canvases(canvases, Rectangle::new(Point::new(0, 0), screensize));
None => info!("GAM: attempt to get bounds on bogus canvas gid {:?}, {:?} ignored.", gid, envelope),
}
},
Opcode::PowerDownRequest => {
powerdown_requested = true;
graphics_server::draw_sleepscreen(gfx_conn).expect("GAM: couldn't draw sleep screen");
// a screen flush is part of the draw_sleepscreen abstraction
xous::return_scalar(envelope.sender, 1).expect("GAM: couldn't confirm power down UI request");
},
Opcode::Redraw => {
if powerdown_requested {
continue; // don't allow any redraws if a powerdown is requested
}
if let Ok(elapsed_time) = ticktimer_server::elapsed_ms(ticktimer_conn) {
if elapsed_time - last_time > 33 { // rate limit updates, no point in going faster than the eye can see
last_time = elapsed_time;
if ccc.connection.is_some() {
ccc.redraw_canvas().expect("GAM: couldn't issue redraw to content canvas");
}
deface(gfx_conn, &mut canvases);
graphics_server::flush(gfx_conn).expect("GAM: couldn't flush buffer to screen");
/* // this throws errors right now because deface() doesn't work.
for (_, c) in canvases.iter_mut() {
c.do_flushed();
}*/
}
}
},
_ => todo!("GAM: opcode not yet implemented"),
}
} else if let xous::Message::MutableBorrow(m) = &envelope.body {
let mut buf = unsafe { xous::XousBuffer::from_memory_message(m) };
let value = unsafe {
archived_value_mut::<api::Opcode>(Pin::new(buf.as_mut()), m.id as usize)
};
match &*value {
rkyv::Archived::<api::Opcode>::RenderTextView(rtv) => {
let mut tv = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: rendertextview {:?}", tv);}
match tv.get_op() {
TextOp::Nop => (),
TextOp::Render | TextOp::ComputeBounds => {
if debug1{info!("GAM: render request for {:?}", tv);}
if tv.get_op() == TextOp::ComputeBounds {
tv.dry_run = true;
} else {
cb.granted = None;
tv.dry_run = false;
}
// pack our data back into the buffer to return
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::SetCanvasBounds(cb)).expect("GAM: SetCanvasBoundsRequest couldn't re-archive return value");
},
rkyv::Archived::<api::Opcode>::RequestContentCanvas(rcc) => {
let mut req: ContentCanvasRequest = rcc.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: RequestContentCanvas {:?}", req);}
// for now, we do nothing with the incoming gid value; but, in the future, we can use it
// as an authentication token perhaps to control access
//// here make a connection back to the requesting server, so that we can tell it to redraw if the layout has changed, etc.
if let Ok(cc) = xous_names::request_connection_blocking(req.servername.as_str().expect("GAM: malformed server name in content canvas request")) {
ccc.connection = Some(cc);
} else {
log::error!("GAM: content requestor gave us a bogus canvas result, aborting");
continue;
};
req.canvas = chatlayout.content;
// pack our data back into the buffer to return
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::RequestContentCanvas(req)).expect("GAM: RequestContentCanvas couldn't re-archive return value");
},
_ => panic!("GAM: invalid mutable borrow message"),
};
} else if let xous::Message::Borrow(m) = &envelope.body {
let buf = unsafe { xous::XousBuffer::from_memory_message(m) };
let bytes = Pin::new(buf.as_ref());
let value = unsafe {
archived_value::<api::Opcode>(&bytes, m.id as usize)
};
match &*value {
rkyv::Archived::<api::Opcode>::RenderObject(rtv) => {
let obj: GamObject = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: renderobject {:?}", obj);}
if let Some(canvas) = canvases.get_mut(&obj.canvas) {
if let Some(canvas) = canvases.get_mut(&tv.get_canvas_gid()) {
// first, figure out if we should even be drawing to this canvas.
if canvas.is_drawable() {
match obj.obj {
GamObjectType::Line(mut line) => {
line.translate(canvas.clip_rect().tl);
line.translate(canvas.pan_offset());
graphics_server::draw_line_clipped(gfx_conn,
line,
canvas.clip_rect(),
).expect("GAM: couldn't draw line");
},
GamObjectType::Circ(mut circ) => {
circ.translate(canvas.clip_rect().tl);
circ.translate(canvas.pan_offset());
graphics_server::draw_circle_clipped(gfx_conn,
circ,
canvas.clip_rect(),
).expect("GAM: couldn't draw circle");
},
GamObjectType::Rect(mut rect) => {
rect.translate(canvas.clip_rect().tl);
rect.translate(canvas.pan_offset());
graphics_server::draw_rectangle_clipped(gfx_conn,
rect,
canvas.clip_rect(),
).expect("GAM: couldn't draw rectangle");
},
GamObjectType::RoundRect(mut rr) => {
rr.translate(canvas.clip_rect().tl);
rr.translate(canvas.pan_offset());
graphics_server::draw_rounded_rectangle_clipped(gfx_conn,
rr,
canvas.clip_rect(),
).expect("GAM: couldn't draw rounded rectangle");
}
}
// set the clip rectangle according to the canvas' location
tv.clip_rect = Some(canvas.clip_rect().into());
// you have to clone the tv object, because if you don't the same block of
// memory gets passed on to the graphics_server(). Which is efficient, but,
// the call will automatically Drop() the memory, which causes a panic when
// this routine returns.
let mut tv_clone = tv.clone();
// issue the draw command
graphics_server::draw_textview(gfx_conn, &mut tv_clone).expect("GAM: text view draw could not complete.");
// copy back the fields that we want to be mutable
if debug1{info!("GAM: got computed cursor of {:?}", tv_clone.cursor);}
tv.cursor = tv_clone.cursor;
tv.bounds_computed = tv_clone.bounds_computed;
// pack our data back into the buffer to return
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::RenderTextView(tv)).expect("GAM: couldn't re-archive return value");
canvas.do_drawn().expect("GAM: couldn't set canvas to drawn");
} else {
info!("GAM: attempt to draw Object on non-drawable canvas. Not fatal, but request ignored.");
info!("GAM: attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored.");
}
} else {
info!("GAM: bogus GID in Object, not doing anything in response to draw request.");
info!("GAM: bogus GID {:?} in TextView {}, not doing anything in response to draw request.", tv.get_canvas_gid(), tv.text);
// silently fail if a bogus Gid is given???
}
if debug1{info!("GAM: leaving RenderObject");}
},
_ => panic!("GAM: invalid borrow message"),
};
} else {
panic!("GAM: unhandled message {:?}", envelope);
}
// /*
},
_ => xous::yield_slice(),
// envelope implements Drop(), which includes a call to syscall::return_memory(self.sender, message.buf)
}
},
rkyv::Archived::<api::Opcode>::SetCanvasBounds(rcb) => {
let mut cb: SetCanvasBoundsRequest = rcb.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: SetCanvasBoundsRequest {:?}", cb);}
// ASSUME:
// very few canvases allow dynamic resizing, so we special case these
if cb.canvas == chatlayout.input {
let newheight = chatlayout.resize_input(cb.requested.y, &mut canvases).expect("GAM: SetCanvasBoundsRequest couldn't recompute input canvas height");
cb.granted = Some(newheight);
canvases = recompute_canvases(canvases, Rectangle::new(Point::new(0, 0), screensize));
// auto-redraw code used to be here, but I think it's a bad idea....causes more
// graphics traffic than necessary? Trying out redraw-on-demand by clients.
if ccc.connection.is_some() {
ccc.redraw_canvas().expect("GAM: couldn't issue redraw to content canvas");
}
} else {
cb.granted = None;
}
// pack our data back into the buffer to return
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::SetCanvasBounds(cb)).expect("GAM: SetCanvasBoundsRequest couldn't re-archive return value");
},
rkyv::Archived::<api::Opcode>::RequestContentCanvas(rcc) => {
let mut req: ContentCanvasRequest = rcc.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: RequestContentCanvas {:?}", req);}
// for now, we do nothing with the incoming gid value; but, in the future, we can use it
// as an authentication token perhaps to control access
//// here make a connection back to the requesting server, so that we can tell it to redraw if the layout has changed, etc.
if let Ok(cc) = xous_names::request_connection_blocking(req.servername.as_str().expect("GAM: malformed server name in content canvas request")) {
ccc.connection = Some(cc);
} else {
log::error!("GAM: content requestor gave us a bogus canvas result, aborting");
continue;
};
req.canvas = chatlayout.content;
// pack our data back into the buffer to return
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
writer.serialize_value(&api::Opcode::RequestContentCanvas(req)).expect("GAM: RequestContentCanvas couldn't re-archive return value");
},
_ => panic!("GAM: invalid mutable borrow message"),
};
} else if let xous::Message::Borrow(m) = &envelope.body {
let buf = unsafe { xous::XousBuffer::from_memory_message(m) };
let bytes = Pin::new(buf.as_ref());
let value = unsafe {
archived_value::<api::Opcode>(&bytes, m.id as usize)
};
match &*value {
rkyv::Archived::<api::Opcode>::RenderObject(rtv) => {
let obj: GamObject = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
if debug1{info!("GAM: renderobject {:?}", obj);}
if let Some(canvas) = canvases.get_mut(&obj.canvas) {
// first, figure out if we should even be drawing to this canvas.
if canvas.is_drawable() {
match obj.obj {
GamObjectType::Line(mut line) => {
line.translate(canvas.clip_rect().tl);
line.translate(canvas.pan_offset());
graphics_server::draw_line_clipped(gfx_conn,
line,
canvas.clip_rect(),
).expect("GAM: couldn't draw line");
},
GamObjectType::Circ(mut circ) => {
circ.translate(canvas.clip_rect().tl);
circ.translate(canvas.pan_offset());
graphics_server::draw_circle_clipped(gfx_conn,
circ,
canvas.clip_rect(),
).expect("GAM: couldn't draw circle");
},
GamObjectType::Rect(mut rect) => {
rect.translate(canvas.clip_rect().tl);
rect.translate(canvas.pan_offset());
graphics_server::draw_rectangle_clipped(gfx_conn,
rect,
canvas.clip_rect(),
).expect("GAM: couldn't draw rectangle");
},
GamObjectType::RoundRect(mut rr) => {
rr.translate(canvas.clip_rect().tl);
rr.translate(canvas.pan_offset());
graphics_server::draw_rounded_rectangle_clipped(gfx_conn,
rr,
canvas.clip_rect(),
).expect("GAM: couldn't draw rounded rectangle");
}
}
canvas.do_drawn().expect("GAM: couldn't set canvas to drawn");
} else {
info!("GAM: attempt to draw Object on non-drawable canvas. Not fatal, but request ignored.");
}
} else {
info!("GAM: bogus GID in Object, not doing anything in response to draw request.");
}
if debug1{info!("GAM: leaving RenderObject");}
},
_ => panic!("GAM: invalid borrow message"),
};
} else {
panic!("GAM: unhandled message {:?}", envelope);
}
}
}

View file

@ -49,6 +49,8 @@ pub struct TextView {
// this is the operation as specified for the GAM. Note this is different from the "op" when sent to graphics-server
// only the GAM should be sending TextViews to the graphics-server, and a different coding scheme is used for that link.
operation: TextOp,
canvas: Gid, // GID of the canvas to draw on
pub clip_rect: Option<Rectangle>, // this is set by the GAM to the canvas' clip_rect; needed by gfx for drawing. Note this is in screen coordinates.
pub untrusted: bool, // render content with random stipples to indicate the strings within are untrusted
pub token: Option<[u32; 4]>, // optional 128-bit token which is presented to prove a field's trustability
@ -75,9 +77,6 @@ pub struct TextView {
// this field specifies the beginning and end of a "selected" region of text
pub selected: Option<[u32; 2]>,
canvas: Gid, // GID of the canvas to draw on
pub clip_rect: Option<Rectangle>, // this is set by the GAM to the canvas' clip_rect; needed by gfx for drawing. Note this is in screen coordinates.
pub text: xous::String::<3072>,
}
impl TextView {

View file

@ -7,10 +7,12 @@ description = "Program to test various aspects of the kernel"
[dependencies]
xous = { path = "../../xous-rs" }
log-server = { path = "../log-server" }
ticktimer-server = { path = "../ticktimer-server" }
log = "0.4"
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}
[features]
logging = [] # adding this allocates the UART for logging of Xous
default = ["logging"]
default = []

View file

@ -1,336 +1,53 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
#[cfg(baremetal)]
#[macro_use]
mod debug;
fn sleep_loop(sleep_ms: usize) {
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap();
let tid = xous::current_tid().unwrap();
let sleep_ms = match tid {
4 => 50,
2 => 10,
3 => 20,
_ => panic!("Unknown TID"),
};
// log::info!("My thread number is {}, sleeping 0x{:08x} ({}) ms", tid, sleep_ms, sleep_ms);
use core::fmt::Write;
use xous::String;
#[cfg(not(target_os = "none"))]
mod implementation {
use core::fmt::{Error, Write};
use std::sync::mpsc::{channel, Receiver, Sender};
enum ControlMessage {
Text(String),
Byte(u8),
Exit,
}
pub struct Output {
tx: Sender<ControlMessage>,
rx: Receiver<ControlMessage>,
stdout: std::io::Stdout,
}
pub fn init() -> Output {
let (tx, rx) = channel();
Output {
tx,
rx,
stdout: std::io::stdout(),
}
}
impl Output {
pub fn run(&mut self) {
use std::io::Write;
loop {
match self.rx.recv_timeout(std::time::Duration::from_millis(50)) {
Ok(msg) => match msg {
ControlMessage::Exit => break,
ControlMessage::Text(s) => print!("{}", s),
ControlMessage::Byte(s) => {
let mut handle = self.stdout.lock();
handle.write_all(&[s]).unwrap();
}
},
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {}
Err(e) => panic!("Error: {}", e),
}
}
}
pub fn get_writer(&self) -> OutputWriter {
OutputWriter {
tx: self.tx.clone(),
}
}
}
impl Drop for Output {
fn drop(&mut self) {
self.tx.send(ControlMessage::Exit).unwrap();
}
}
impl Write for Output {
fn write_str(&mut self, s: &str) -> Result<(), Error> {
// It would be nice if this worked with &str
self.tx.send(ControlMessage::Text(s.to_owned())).unwrap();
Ok(())
}
}
pub struct OutputWriter {
tx: Sender<ControlMessage>,
}
impl OutputWriter {
pub fn putc(&self, c: u8) {
self.tx.send(ControlMessage::Byte(c)).unwrap();
}
}
impl Write for OutputWriter {
fn write_str(&mut self, s: &str) -> Result<(), Error> {
// It would be nice if this worked with &str
self.tx.send(ControlMessage::Text(s.to_owned())).unwrap();
Ok(())
}
}
}
#[cfg(target_os = "none")]
mod implementation {
use core::fmt::{Error, Write};
use utralib::generated::*;
pub struct Output {}
pub fn init() -> Output {
if cfg!(feature = "logging") {
let uart = xous::syscall::map_memory(
xous::MemoryAddress::new(utra::console::HW_CONSOLE_BASE),
None,
4096,
xous::MemoryFlags::R | xous::MemoryFlags::W,
)
.expect("couldn't map serial port");
unsafe { crate::debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() as _ };
println!("Mapped UART @ {:08x}", uart.addr.get());
println!("Process: map success!");
crate::debug::DEFAULT.enable_rx();
println!("Allocating IRQ...");
xous::syscall::claim_interrupt(
utra::console::CONSOLE_IRQ,
handle_irq,
core::ptr::null_mut::<usize>(),
)
.expect("couldn't claim interrupt");
println!("Claimed IRQ {}", utra::console::CONSOLE_IRQ);
}
Output {}
}
impl Output {
pub fn get_writer(&self) -> OutputWriter {
OutputWriter {}
}
pub fn run(&mut self) {
loop {
xous::wait_event();
}
}
}
fn handle_irq(irq_no: usize, arg: *mut usize) {
if cfg!(feature = "logging") {
print!("Handling IRQ {} (arg: {:08x}): ", irq_no, arg as usize);
while let Some(c) = crate::debug::DEFAULT.getc() {
print!("0x{:02x}", c);
}
println!();
}
}
pub struct OutputWriter {}
impl OutputWriter {
pub fn putc(&self, c: u8) {
if cfg!(feature = "logging") {
let mut uart_csr = CSR::new(unsafe { crate::debug::DEFAULT_UART_ADDR as *mut u32 });
// Wait until TXFULL is `0`
while uart_csr.r(utra::uart::TXFULL) != 0 {}
uart_csr.wo(utra::uart::RXTX, c as u32);
}
}
}
impl Write for OutputWriter {
fn write_str(&mut self, s: &str) -> Result<(), Error> {
for c in s.bytes() {
self.putc(c);
if c == '\n' as u8 {
self.putc('\r' as u8);
}
}
Ok(())
}
}
}
fn handle_scalar(
output: &mut implementation::OutputWriter,
sender: xous::MessageSender,
msg: &xous::ScalarMessage,
sender_pid: xous::PID,
) {
match msg.id {
1000 => writeln!(output, "PANIC from PID {} | {}", sender_pid, sender).unwrap(),
1100 => (),
1101..=1132 => {
let mut output_bfr = [0u8; core::mem::size_of::<usize>() * 4];
let output_iter = output_bfr.iter_mut();
// Combine the four arguments to form a single
// contiguous buffer. Note: The buffer size will change
// depending on the platfor's `usize` length.
let arg1_bytes = msg.arg1.to_le_bytes();
let arg2_bytes = msg.arg2.to_le_bytes();
let arg3_bytes = msg.arg3.to_le_bytes();
let arg4_bytes = msg.arg4.to_le_bytes();
let input_iter = arg1_bytes
.iter()
.chain(arg2_bytes.iter())
.chain(arg3_bytes.iter())
.chain(arg4_bytes.iter());
for (dest, src) in output_iter.zip(input_iter) {
*dest = *src;
}
let total_chars = msg.id - 1100;
for (idx, c) in output_bfr.iter().enumerate() {
if idx >= total_chars {
break;
}
output.putc(*c);
}
}
1200 => writeln!(output, "Terminating process").unwrap(),
_ => writeln!(
output,
"Unrecognized scalar message from {}: {:#?}",
sender, msg
)
.unwrap(),
}
}
fn reader_thread(mut output: implementation::OutputWriter) {
writeln!(output, "LOG: Xous Logging Server starting up...").unwrap();
writeln!(output, "LOG: ****************************************************************").unwrap();
// time stamp isn't actually the time stamp of the build, unfortunately. It's the time stamp of the
// last time you managed to force a rebuild that also causes log-server to be rebuilt, not necessarily
// capturing the build time of the very most recent change!
// writeln!(output, "LOG: *** Built: {:49} ***", env!("VERGEN_BUILD_TIMESTAMP")).unwrap();
writeln!(output, "LOG: ****************************************************************").unwrap();
let server_addr = xous::create_server_with_address(b"xous-log-server ").unwrap();
writeln!(output, "LOG: Server listening on address {:?}", server_addr).unwrap();
let mut counter: usize = 0;
let mut loop_count = 0;
loop {
if counter.trailing_zeros() >= 12 {
writeln!(output, "LOG: Counter tick: {}", counter).unwrap();
}
counter += 1;
// writeln!(output, "LOG: Waiting for an event...").unwrap();
let mut envelope =
xous::syscall::receive_message(server_addr).expect("couldn't get address");
let sender = envelope.sender;
// writeln!(output, "LOG: Got message envelope: {:?}", envelope).unwrap();
match &mut envelope.body {
xous::Message::Scalar(msg) => handle_scalar(&mut output, sender, msg, envelope.sender.pid().unwrap()),
xous::Message::BlockingScalar(msg) => {
writeln!(
output,
"LOG: BlockingScalar message from {}: {:?}",
envelope.sender, msg
)
.unwrap();
}
xous::Message::Move(msg) => {
String::<4000>::from_message(msg)
.map(|log_entry: String<4000>| {
writeln!(
output,
"LOG: Moved log message from {}: {}",
sender, log_entry
)
.unwrap()
})
.or_else(|e| {
writeln!(output, "LOG: unable to convert Move message to str: {}", e)
})
.ok();
}
xous::Message::Borrow(msg) => {
String::<4000>::from_message(msg)
.map(|log_entry: String<4000>| writeln!(output, "{}", log_entry).unwrap())
.or_else(|e| {
writeln!(
output,
"LOG: unable to convert Borrow message to str: {}",
e
)
})
.ok();
}
xous::Message::MutableBorrow(msg) => {
String::<4000>::from_message(msg)
.map(|mut log_entry: String<4000>| {
writeln!(
output,
"LOG: Mutable borrowed log message from {} len {}:\n\r {}\n\r",
sender,
log_entry.len(),
log_entry,
)
.unwrap();
writeln!(log_entry, " << HELLO FROM THE SERVER").unwrap();
})
.or_else(|e| {
writeln!(
output,
"LOG: unable to convert MutableBorrow message to str: {}",
e
)
})
.ok();
}
}
}
}
fn writer_thread(_ignored: usize) {
let mut counter = 0;
loop {
let conn = xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap()).unwrap();
let mut buffer = xous::String::<4000>::new();
write!(buffer, "Hello, myself! Loop: {}", counter).unwrap();
buffer.lend(conn).unwrap();
counter += 1;
// log::info!(
// "TEST THREAD {}: {}ms Number of times slept: {}",
// tid,
// sleep_ms,
// loop_count
// );
let start_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
ticktimer_server::sleep_ms(ticktimer_conn, sleep_ms).unwrap();
let end_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
log::info!(
"TEST THREAD {}: target {}ms, {} loops: Sleep finished (uptime: {}, took {} ms)",
tid,
sleep_ms,
loop_count,
end_time,
end_time - start_time,
);
loop_count += 1;
}
}
#[xous::xous_main]
fn test_main() -> ! {
let mut output = implementation::init();
let writer = output.get_writer();
println!("LOG: my PID is {}", xous::process::id());
println!("LOG: Creating the reader thread");
xous::create_thread_simple(reader_thread, writer).unwrap();
xous::create_thread_simple(writer_thread, 0usize).unwrap();
println!("LOG: Running the output");
output.run();
loop {}
log_server::init_wait().unwrap();
xous::create_thread_simple(sleep_loop, 10).unwrap();
xous::create_thread_simple(sleep_loop, 5).unwrap();
xous::create_thread_simple(sleep_loop, 2).unwrap();
// let mut ms_count = 1;
loop {
xous::wait_event();
// log::info!("Loop {}", ms_count);
// sleep_ms(ticktimer_conn, 1).unwrap();
// ms_count += 1;
}
}

22
services/rtc/Cargo.toml Normal file
View file

@ -0,0 +1,22 @@
[package]
name = "rtc"
version = "0.1.0"
authors = ["bunnie <bunnie@kosagi.com>"]
edition = "2018"
description = "RTC server"
[dependencies]
xous = { path = "../../xous-rs" }
heapless = "0.5.6"
log-server = { path = "../log-server" }
ticktimer-server = { path = "../ticktimer-server" }
xous-names = { path = "../xous-names" }
log = "0.4"
bitflags = "1.2.1"
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}
[features]
debugprint = []
default = [] # "debugprint"

73
services/rtc/src/api.rs Normal file
View file

@ -0,0 +1,73 @@
use xous::{Message, ScalarMessage};
pub enum Weekday {
Sunday,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
}
pub enum TimeUnits {
Seconds,
Minutes,
Hours,
}
pub struct DateTime {
pub seconds: u8,
pub minutes: u8,
pub hours: u8,
pub days: u8,
pub months: u8,
pub years: u8,
pub weekday: Weekday,
}
#[allow(dead_code)]
#[derive(Debug)]
pub enum Opcode {
/// Get datetime. This will be accurate to +/-2s, as the RTC is updated from hardware
/// once a second.
GetDateTime,
/// sets the datetime
SetDateTime(DateTime),
/// sets a wake-up alarm. This forces the SoC into power-on state, if it happens to be off.
/// primarily used to trigger cold reboots, but could have other reasons
SetWakeupAlarm(u8, TimeUnits),
/// clear any wakeup alarms that have been set
ClearWakeupAlarm,
}
impl core::convert::TryFrom<& Message> for Opcode {
type Error = &'static str;
fn try_from(message: & Message) -> Result<Self, Self::Error> {
match message {
Message::BlockingScalar(m) => match m.id {
0 => Ok(Opcode::GetTrng(m.arg1)),
_ => Err("TRNG api: unknown BlockingScalar ID"),
},
_ => Err("TRNG api: unhandled message type"),
}
}
}
impl Into<Message> for Opcode {
fn into(self) -> Message {
match self {
Opcode::GetTrng(count) => Message::BlockingScalar(ScalarMessage {
id: 0,
arg1: count.into(),
arg2: 0,
arg3: 0,
arg4: 0,
}),
// _ => panic!("TRNG api: Opcode type not handled by Into(), refer to helper method"),
}
}
}

22
services/rtc/src/lib.rs Normal file
View file

@ -0,0 +1,22 @@
#![cfg_attr(target_os = "none", no_std)]
pub mod api;
use xous::{CID, send_message};
pub fn get_u32(cid: CID) -> Result<u32, xous::Error> {
let response = send_message(cid, api::Opcode::GetTrng(1).into())?;
if let xous::Result::Scalar2(trng, _) = response {
Ok(trng as u32)
} else {
panic!("unexpected return value: {:#?}", response);
}
}
pub fn get_u64(cid: CID) -> Result<u64, xous::Error> {
let response = send_message(cid, api::Opcode::GetTrng(2).into())?;
if let xous::Result::Scalar2(lo, hi) = response {
Ok( lo as u64 | ((hi as u64) << 32) )
} else {
panic!("unexpected return value: {:#?}", response);
}
}

404
services/rtc/src/main.rs Normal file
View file

@ -0,0 +1,404 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
mod api;
use api::*;
use core::convert::TryFrom;
use log::{error, info};
#[cfg(target_os = "none")]
mod implementation {
use log::info;
#[macro_use]
use bitflags::*;
const ABRTCMC_I2C_ADR: u8 = 0x68;
const ABRTCMC_CONTROL1: u8 = 0x00;
bitflags! {
pub struct Control1: u8 {
const CORRECTION_INT = 0b0000_0001;
const ALARM_INT = 0b0000_0010;
const SECONDS_INT = 0b0000_0100;
const HR_MODE_12 = 0b0000_1000;
const SOFT_RESET = 0b0001_0000;
const STOP = 0b0010_0000;
}
}
const ABRTCMC_CONTROL2: u8 = 0x01;
bitflags! {
pub struct Control2: u8 {
const COUNTDOWN_B_INT = 0b0000_0001;
const COUNTDOWN_A_INT = 0b0000_0010;
const WATCHDOG_A_INT = 0b0000_0100;
const ALARM_HAPPENED = 0b0000_1000;
const SECONDS_HAPPENED= 0b0001_0000;
const COUNTB_HAPPENED = 0b0010_0000;
const COUNTA_HAPPENED = 0b0100_0000;
const WATCHA_HAPPENED = 0b1000_0000;
}
}
const ABRTCMC_CONTROL3: u8 = 0x02;
bitflags! {
pub struct Control3: u8 {
const BATTLOW_INT = 0b0000_0001;
const BATTSWITCH_INT = 0b0000_0010;
const BATTLOW_STAT = 0b0000_0100;
const BATTSW_HAPPENED = 0b0000_1000;
const BATT_STD_BL_EN = 0b0000_0000;
const BATT_DIR_BL_EN = 0b0010_0000;
const BATT_DIS_BL_EN = 0b0100_0000;
const BATT_STD_BL_DIS = 0b1000_0000;
const BATT_DI_BL_DIS = 0b1110_0000;
}
}
const ABRTCMC_SECONDS: u8 = 0x3;
bitflags! {
pub struct Seconds: u8 {
const SECONDS_BCD = 0b0111_1111;
const CORRUPTED = 0b1000_0000;
}
}
const ABRTCMC_MINUTES: u8 = 0x4;
// no bitflags, minutes are BCD whole register
const ABRTCMC_HOURS: u8 = 0x5;
bitflags! {
pub struct Hours: u8 {
const HR12_HOURS_BCD = 0b0001_1111;
const HR12_PM_FLAG = 0b0010_0000;
const HR24_HOURS_BCD = 0b0011_1111;
}
}
const ABRTCMC_DAYS: u8 = 0x6;
// no bitflags, days are BCD whole register
const ABRTCMC_WEEKDAYS: u8 = 0x7;
bitflags! {
pub struct Weekdays: u8 {
const SUNDAY = 0b000;
const MONDAY = 0b001;
const TUESDAY = 0b010;
const WEDNESDAY= 0b011;
const THURSDAY = 0b100;
const FRIDAY = 0b101;
const SATURDAY = 0b110;
}
}
const ABRTCMC_MONTHS: u8 = 0x8;
bitflags! {
pub struct Months: u8 { // BCD "months"
const JANUARY = 0b0_0001;
const FEBRUARY = 0b0_0010;
const MARCH = 0b0_0011;
const APRIL = 0b0_0100;
const MAY = 0b0_0101;
const JUNE = 0b0_0110;
const JULY = 0b0_0111;
const AUGUST = 0b0_1000;
const SEPTEMBER = 0b0_1001;
const OCTOBER = 0b1_0000;
const NOVEMBER = 0b1_0001;
const DECEMBER = 0b1_0010;
}
}
const ABRTCMC_YEARS: u8 = 0x9;
// no bitflags, years are 00-99 in BCD format
const ABRTCMC_MINUTE_ALARM: u8 = 0xA;
const ABRTCMC_HOUR_ALARM: u8 = 0xB;
const ABRTCMC_DAY_ALARM: u8 = 0xC;
const ABRTCMC_WEEKDAY_ALARM: u8 = 0xD;
bitflags! {
pub struct Alarm: u8 {
const ENABLE = 0b1000_0000;
// all others code minute/hour/day/weekday in BCD LSBs
const HR12_PM_FLAG = 0b0010_0000; // only used in hours alarm, 12-hour mode
}
}
const ABRTCMC_CONFIG: u8 = 0xF;
bitflags! {
pub struct Config: u8 {
const TIMER_B_ENABLE = 0b0000_0001;
const TIMER_A_WATCHDOG = 0b0000_0100;
const TIMER_A_COUNTDWN = 0b0000_0010;
const TIMER_A_DISABLE = 0b0000_0000;
const TIMER_A_DISABLE2 = 0b0000_0110;
const CLKOUT_32768_HZ = 0b0000_0000;
const CLKOUT_16384_HZ = 0b0000_1000;
const CLKOUT_8192_HZ = 0b0001_0000;
const CLKOUT_4096_HZ = 0b0001_1000;
const CLKOUT_1024_HZ = 0b0010_0000;
const CLKOUT_32_HZ = 0b0010_1000;
const CLKOUT_1_HZ = 0b0011_0000;
const CLKOUT_DISABLE = 0b0011_1000;
const TIMERB_INT_PULSED = 0b0100_0000;
const TIMERA_SECONDS_INT_PULSED = 0b1000_0000;
}
}
const ABRTCMC_TIMERA_CLK: u8 = 0x10;
const ABRTCMC_TIMERB_CLK: u8 = 0x12;
bitflags! {
pub struct TimerClk: u8 {
const CLK_3600_S = 0b0000_0100;
const CLK_60_S = 0b0000_0011;
const CLK_1_S = 0b0000_0010;
const CLK_64_HZ = 0b0000_0001; // 15.625ms
const CLK_4096_HZ = 0b0000_0000; // 0.2441ms
const PULSE_46_MS = 0b0000_0000;
const PULSE_62_MS = 0b0001_0000;
const PULSE_78_MS = 0b0010_0000;
const PULSE_93_MS = 0b0011_0000;
const PULSE_125_MS = 0b0100_0000;
const PULSE_156_MS = 0b0101_0000;
const PULSE_187_MS = 0b0110_0000;
const PULSE_218_MS = 0b0111_0000;
}
}
const ABRTCMC_TIMERA: u8 = 0x11;
// no bitflags, register is timer period in seconds, and the period is N / (source clock frequency)
const ABRTCMC_TIMERB: u8 = 0x13;
// no bitflags, register is timer period in seconds, and the period is N / (source clock frequency)
/// convert binary to BCD
fn to_bcd(binary: u8) -> u8 {
let mut lsd: u8 = binary % 10;
if lsd > 9 {
lsd = 9;
}
let mut msd: u8 = binary / 10;
if msd > 9 {
msd = 9;
}
(msd << 4) | lsd
}
fn to_binary(bcd: u8) -> u8 {
(bcd & 0xf) + ((bcd >> 4) * 10)
}
fn to_weekday(bcd: u8) -> Weekdays {
match bcd {
0 => Weekdays::SUNDAY,
1 => Weekdays::MONDAY,
2 => Weekdays::TUESDAY,
3 => Weekdays::WEDNESDAY,
4 => Weekdays::THURSDAY,
5 => Weekdays::FRIDAY,
6 => Weekdays::SATURDAY,
_ => Weekdays::SUNDAY,
}
}
pub struct Rtc {
pub seconds: u8,
pub minutes: u8,
pub hours: u8,
pub days: u8,
pub months: u8,
pub years: u8,
pub weekday: Weekdays,
updated_ticks: u64,
}
impl Rtc {
pub fn new() -> Rtc {
info!("RTC: hardware initialized");
Rtc {
seconds: 0,
minutes: 0,
hours: 0,
days: 0,
months: 0,
years: 0,
weekday: Weekdays::SUNDAY,
updated_ticks: 0,
}
}
/// we only support 24 hour mode
/// TODO: sanity check arguments
/// TODO: write accesses should happen in a single block, to guarante atomicity of the operation
pub fn rtc_set(&mut self, secs: u8, mins: u8, hours: u8, days: u8, months: u8, years: u8, d: Weekdays) -> bool {
let mut txbuf: [u8; 2];
// make sure battery switchover is enabled, otherwise we won't keep time when power goes off
txbuf = [ABRTCMC_CONTROL3, (Control3::BATT_STD_BL_EN).bits()];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
txbuf = [ABRTCMC_SECONDS, to_bcd(secs)];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
self.updated_ticks = get_ticks(&self.p);
self.seconds = secs;
txbuf = [ABRTCMC_MINUTES, to_bcd(mins)];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
self.minutes = mins;
txbuf = [ABRTCMC_HOURS, to_bcd(hours)];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
self.hours = hours;
txbuf = [ABRTCMC_DAYS, to_bcd(days)];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
self.days = days;
txbuf = [ABRTCMC_MONTHS, to_bcd(months)];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
self.months = months;
txbuf = [ABRTCMC_YEARS, to_bcd(years)];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
self.years = years;
txbuf = [ABRTCMC_WEEKDAYS, d.bits()];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
self.weekday = d;
true // sanity check args would return false on fail
}
pub fn rtc_update(&mut self) {
let txbuf: [u8; 1];
let mut rxbuf: [u8; 7] = [0; 7];
// only update from RTC if more than 1 second has passed since the last update
if get_ticks(&self.p) - self.updated_ticks > 1000 {
// read as a single block to make the time readout atomic
txbuf = [ABRTCMC_SECONDS];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), Some(&mut rxbuf), I2C_TIMEOUT);
self.seconds = to_binary(rxbuf[0] & 0x7f);
self.minutes = to_binary(rxbuf[1] & 0x7f);
self.hours = to_binary(rxbuf[2] & 0x3f);
self.days = to_binary(rxbuf[3] & 0x3f);
self.weekday = to_weekday(rxbuf[4] & 0x7f);
self.months = to_binary(rxbuf[5] & 0x1f);
self.years = to_binary(rxbuf[6]);
self.updated_ticks = get_ticks(&self.p);
}
}
/// testing-only routine -- wakeup self after designated number of seconds
pub fn wakeup_alarm(&mut self, seconds: u8) {
let mut txbuf: [u8; 2];
// make sure battery switchover is enabled
txbuf = [ABRTCMC_CONTROL3, (Control3::BATT_STD_BL_EN).bits()];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
// set clock units to 1 second, output pulse length to ~218ms
txbuf = [ABRTCMC_TIMERB_CLK, (TimerClk::CLK_1_S | TimerClk::PULSE_218_MS).bits()];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
// program elapsed time
txbuf = [ABRTCMC_TIMERB, seconds];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
// enable timerb countdown interrupt, also clears any prior interrupt flag
txbuf = [ABRTCMC_CONTROL2, (Control2::COUNTDOWN_B_INT).bits()];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
// turn on the timer proper -- the system will restart in 5...4..3....
txbuf = [ABRTCMC_CONFIG, (Config::TIMER_B_ENABLE | Config::CLKOUT_DISABLE).bits()];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
}
pub fn clear_alarm(&mut self) {
// turn off RTC wakeup timer, in case previously set
let mut txbuf : [u8; 2] = [ABRTCMC_CONFIG, (Config::CLKOUT_DISABLE).bits()];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
// clear all interrupts and flags
txbuf = [ABRTCMC_CONTROL2, 0];
i2c_controller(&self.p, ABRTCMC_I2C_ADR, Some(&txbuf), None, I2C_TIMEOUT);
}
}
}
// a stub to try to avoid breaking hosted mode for as long as possible.
#[cfg(not(target_os = "none"))]
mod implementation {
use log::info;
pub struct Rtc {
pub seconds: u8,
pub minutes: u8,
pub hours: u8,
pub days: u8,
pub months: u8,
pub years: u8,
pub weekday: Weekdays,
updated_ticks: u64,
}
impl Rtc {
pub fn new() -> Rtc {
Rtc {
seconds: 0,
minutes: 0,
hours: 0,
days: 0,
months: 0,
years: 0,
weekday: Weekdays::SUNDAY,
updated_ticks: 0,
}
}
}
}
#[xous::xous_main]
fn xmain() -> ! {
use crate::implementation::Rtc;
log_server::init_wait().unwrap();
info!("RTC: my PID is {}", xous::process::id());
let rtc_sid = xous_names::register_name(xous::names::SERVER_NAME_RTC).expect("RTC: can't register server");
info!("RTC: registered with NS -- {:?}", rtc_sid);
#[cfg(target_os = "none")]
let rtc = Rtc::new();
#[cfg(not(target_os = "none"))]
let mut rtc = Rtc::new();
info!("RTC: ready to accept requests");
loop {
let envelope = xous::receive_message(rtc_sid).unwrap();
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
match opcode {
Opcode::GetRtc(count) => {
let val: [u32; 2] = rtc.get_rtc(count);
xous::return_scalar2(envelope.sender, val[0] as _, val[1] as _)
.expect("RTC: couldn't return GetRtc request");
},
}
} else {
error!("KBD: couldn't convert opcode");
}
}
}

View file

@ -12,7 +12,7 @@ pub fn callback_thread(_: u32) {
if CB_RUN.load(Ordering::Relaxed) {
CB_RUN.store(false, Ordering::Relaxed);
ticktimer_server::sleep_ms(ticktimer_conn, 2000).unwrap();
ticktimer_server::sleep_ms(ticktimer_conn, 10000).unwrap();
// just send a bogus message
xous::send_message(callback_conn, Message::Scalar(ScalarMessage{
id: 0xdeadbeef, arg1: 0, arg2: 0, arg3: 0, arg4: 0,
@ -38,7 +38,7 @@ impl CallBack {
}
impl<'a> ShellCmdApi<'a> for CallBack {
cmd_api!(callback);
cmd_api!(cb);
fn process(&mut self, _args: String::<1024>, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
use core::fmt::Write;

View file

@ -1,23 +1,24 @@
[package]
authors = ["bunnie <bunnie@kosagi.com>"]
description = "Provide high-resolution, non-rollover system time"
edition = "2018"
name = "ticktimer-server"
version = "0.1.0"
authors = ["bunnie <bunnie@kosagi.com>"]
edition = "2018"
description = "Provide high-resolution, non-rollover system time"
[dependencies]
xous = { path = "../../xous-rs" }
heapless = "0.5"
log-server = { path = "../log-server" }
log = "0.4"
log-server = {path = "../log-server"}
xous = {path = "../../xous-rs"}
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}
utralib = {path = "../../utralib"}
[target.'cfg(any(windows,unix))'.dependencies]
[features]
debugprint = []
disablewatchdog = []
debug-print = []
watchdog = []
# generally you want to disable watchdog if you're doing development.
default = ["disablewatchdog"] # "debugprint"
default = ["watchdog"]
# default = ["debug-print"]

View file

@ -1,5 +1,10 @@
use xous::{Message, ScalarMessage};
#[derive(Debug)]
pub struct TimerToken {
token: u64, // this field is 48 bits wide, random number
}
#[derive(Debug)]
pub enum Opcode {
/// Reset the timer
@ -13,6 +18,24 @@ pub enum Opcode {
/// Recalculate the sleep time
RecalculateSleep,
/*
////////// new APIs
/// Subscribe to wakeup alarms. Takes in the server name that's subcribed, returns a Token to refer to the subscription.
SubscribeWakeup(xous::String::<64>),
/// set an alarm in milliseconds, which is returned via the SubscribeWakeup registration token
WakeupAlarm(u16, TimerToken),
/// The generic message that gets sent to other servers, at the alarm time
WakeupMessage,
/// Request a blocking, in-line delay server -- returns a CID that can be used to send the BlockingDelayMs message
/// each request consumes a thread in the ticktimer that tracks & responds to a blockingdelay
RequestBlockingDelay,
/// Do a blocking delay. Responds with the current ElapsedMs by default.
BlockingDelayMs(u32),
*/
}
impl<'a> core::convert::TryFrom<&'a Message> for Opcode {

View file

@ -6,32 +6,50 @@ use api::Opcode;
mod os_timer;
use core::convert::TryFrom;
use heapless::binary_heap::{BinaryHeap, Min};
use heapless::consts::*;
use core::convert::TryFrom;
use log::{error, info};
#[derive(Eq, Debug)]
pub struct SleepResponse {
msec: usize,
#[derive(Eq)]
pub struct SleepRequest {
msec: i64,
sender: xous::MessageSender,
}
impl core::cmp::Ord for SleepResponse {
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
self.msec.cmp(&other.msec)
impl core::fmt::Display for SleepRequest {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "SleepRequest {{ msec: {}, {} }}", self.msec, self.sender)
}
}
impl core::cmp::PartialOrd for SleepResponse {
impl core::fmt::Debug for SleepRequest {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "SleepRequest {{ msec: {}, {} }}", self.msec, self.sender)
}
}
impl core::cmp::Ord for SleepRequest {
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
if self.msec < other.msec {
core::cmp::Ordering::Less
} else if self.msec > other.msec {
core::cmp::Ordering::Greater
} else {
self.sender.cmp(&other.sender)
}
}
}
impl core::cmp::PartialOrd for SleepRequest {
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl core::cmp::PartialEq for SleepResponse {
impl core::cmp::PartialEq for SleepRequest {
fn eq(&self, other: &Self) -> bool {
self.msec == other.msec && self.sender == other.sender
}
@ -40,14 +58,14 @@ impl core::cmp::PartialEq for SleepResponse {
#[cfg(target_os = "none")]
mod implementation {
const TICKS_PER_MS: u64 = 1;
use super::SleepResponse;
use super::SleepRequest;
use utralib::generated::*;
pub struct XousTickTimer {
csr: utralib::CSR<u32>,
#[cfg(feature = "watchdog")]
wdt: utralib::CSR<u32>,
current_response: Option<SleepResponse>,
response_start: u64,
current_response: Option<SleepRequest>,
connection: xous::CID,
}
@ -58,14 +76,16 @@ mod implementation {
// Safe because we're in an interrupt, and this interrupt is only
// enabled when this value is not None.
let response = xtt.current_response.take().unwrap();
xous::return_scalar(response.sender, 0).expect("couldn't send response");
xtt.csr.wo(utra::ticktimer::EV_ENABLE, 0); // Disable the interrupt
// Disable the timer
xtt.csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, 0);
xtt.csr.wfo(utra::ticktimer::EV_PENDING_ALARM, 1);
// This is dangerous and may panic if the queue is full.
xous::try_send_message(xtt.connection, crate::api::Opcode::RecalculateSleep.into())
.map(|_| ())
.unwrap();
// This is dangerous and may return an error if the queue is full.
// Which is fine, because the queue is always recalculated any time a message arrives.
xous::try_send_message(xtt.connection, crate::api::Opcode::RecalculateSleep.into()).ok();
}
impl XousTickTimer {
@ -88,17 +108,14 @@ mod implementation {
let mut xtt = XousTickTimer {
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
#[cfg(feature = "watchdog")]
wdt: CSR::new(wdt.as_mut_ptr() as *mut u32),
current_response: None,
response_start: 0,
connection,
};
if cfg!(feature = "disablewatchdog") {
// do nothing
} else {
xtt.wdt.wfo(utra::wdt::WATCHDOG_ENABLE, 1);
}
#[cfg(feature = "watchdog")]
xtt.wdt.wfo(utra::wdt::WATCHDOG_ENABLE, 1);
xous::claim_interrupt(
utra::ticktimer::TICKTIMER_IRQ,
@ -126,39 +143,58 @@ mod implementation {
self.raw_ticktime() / TICKS_PER_MS
}
pub fn stop_interrupt(&mut self) -> Option<SleepResponse> {
self.csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, 0); // Disable the timer
let current_value = self.elapsed_ms();
pub fn stop_interrupt(&mut self) -> Option<SleepRequest> {
// Disable the timer
self.csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, 0);
// Now that the interrupt is disabled, we can see if the interrupt handler has a current response.
// If it exists, then that means that an interrupt did NOT fire, and an existing interrupt
// is in place.
if let Some(sr) = self.current_response.take() {
Some(SleepResponse {
msec: (current_value - self.response_start) as _,
sender: sr.sender,
})
#[cfg(feature = "debug-print")]
{
log::info!(
"TickTimer: Stopping currently-running timer sr.msec: {} elapsed_ms: {}",
sr.msec,
self.elapsed_ms()
);
}
Some(sr)
} else {
None
}
}
pub fn schedule_response(&mut self, milliseconds: usize, sender: xous::MessageSender) {
self.current_response = Some(SleepResponse {
sender,
msec: milliseconds,
});
self.response_start = self.elapsed_ms();
let irq_target = self.response_start + (milliseconds as u64);
pub fn schedule_response(&mut self, request: SleepRequest) {
let irq_target = request.msec;
#[cfg(feature = "debug-print")]
log::info!(
"setting a response at {} ms (current time: {} ms)",
"TickTimer: setting a response at {} ms (current time: {} ms)",
irq_target,
self.response_start
self.elapsed_ms()
);
self.csr.wfo(utra::ticktimer::EV_PENDING_ALARM, 1); // Clear previous interrupt (if any)
// Disable the timer interrupt
assert!(self.csr.rf(utra::ticktimer::EV_ENABLE_ALARM) == 0);
self.csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, 0);
// Save a copy of the current sleep request
self.current_response = Some(request);
// Set the new target time
self.csr
.wo(utra::ticktimer::MSLEEP_TARGET1, (irq_target >> 32) as _);
self.csr
.wo(utra::ticktimer::MSLEEP_TARGET0, irq_target as _);
self.csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, 1); // Enable the interrupt
// Clear previous interrupt (if any)
self.csr.wfo(utra::ticktimer::EV_PENDING_ALARM, 1);
// Enable the interrupt
self.csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, 1);
}
#[cfg(feature = "watchdog")]
pub fn reset_wdt(&mut self) {
// disarm the WDT
@ -185,18 +221,22 @@ mod implementation {
#[cfg(not(target_os = "none"))]
mod implementation {
use super::SleepResponse;
use super::SleepRequest;
use std::convert::TryInto;
#[derive(Debug)]
enum SleepComms {
InterruptSleep,
StartSleep(xous::MessageSender, u64 /* ms */),
StartSleep(
xous::MessageSender,
i64, /* ms */
u64, /* elapsed */
),
}
pub struct XousTickTimer {
start: std::time::Instant,
sleep_comms: std::sync::mpsc::Sender<SleepComms>,
time_remaining_receiver: std::sync::mpsc::Receiver<Option<SleepResponse>>,
time_remaining_receiver: std::sync::mpsc::Receiver<Option<SleepRequest>>,
}
impl XousTickTimer {
@ -205,9 +245,8 @@ mod implementation {
let (time_remaining_sender, time_remaining_receiver) = std::sync::mpsc::channel();
xous::create_thread(move || {
let mut timeout = None;
let mut sender = Default::default();
let mut current_response: Option<SleepRequest> = None;
loop {
let start_time = std::time::Instant::now();
let result = match timeout {
None => sleep_receiver
.recv()
@ -216,6 +255,9 @@ mod implementation {
};
match result {
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
let sender = current_response.take().unwrap().sender;
#[cfg(feature = "debug-print")]
log::info!("Returning scalar to {}", sender);
xous::return_scalar(sender, 0).expect("couldn't send response");
// This is dangerous and may panic if the queue is full.
@ -229,19 +271,35 @@ mod implementation {
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
return;
}
Ok(SleepComms::InterruptSleep) => time_remaining_sender
.send(if timeout.is_some() {
Some(SleepResponse {
sender,
msec: start_time.elapsed().as_millis() as _,
})
Ok(SleepComms::InterruptSleep) => {
timeout = None;
time_remaining_sender.send(current_response.take()).unwrap()
}
Ok(SleepComms::StartSleep(new_sender, expiry, elapsed)) => {
let mut duration = expiry - (elapsed as i64);
if duration > 0 {
#[cfg(feature = "debug-print")]
log::info!(
"Starting sleep for {} ms, returning to {}",
duration,
new_sender
);
} else {
None
})
.unwrap(),
Ok(SleepComms::StartSleep(new_sender, duration)) => {
timeout = Some(std::time::Duration::from_millis(duration));
sender = new_sender;
#[cfg(feature = "debug-print")]
log::info!(
"Clamping duration to 0 (was: {})m returning to {}",
duration,
new_sender
);
duration = 0;
}
timeout = Some(std::time::Duration::from_millis(
duration.try_into().unwrap(),
));
current_response = Some(SleepRequest {
sender: new_sender,
msec: expiry,
});
}
}
}
@ -263,17 +321,29 @@ mod implementation {
self.start.elapsed().as_millis().try_into().unwrap()
}
pub fn stop_interrupt(&mut self) -> Option<SleepResponse> {
pub fn stop_interrupt(&mut self) -> Option<SleepRequest> {
self.sleep_comms.send(SleepComms::InterruptSleep).unwrap();
self.time_remaining_receiver.recv().unwrap()
}
pub fn schedule_response(&mut self, milliseconds: usize, sender: xous::MessageSender) {
pub fn schedule_response(&mut self, request: SleepRequest) {
#[cfg(feature = "debug-print")]
log::info!(
"request.msec: {} self.elapsed_ms: {} returning to: {}",
request.msec,
self.elapsed_ms(),
request.sender
);
self.sleep_comms
.send(SleepComms::StartSleep(sender, milliseconds as _))
.send(SleepComms::StartSleep(
request.sender,
request.msec as i64,
self.elapsed_ms(),
))
.unwrap();
}
#[cfg(feature = "watchdog")]
pub fn reset_wdt(&self) {
// dummy function, does nothing
}
@ -284,21 +354,44 @@ use implementation::*;
fn recalculate_sleep(
ticktimer: &mut XousTickTimer,
sleep_heap: &mut BinaryHeap<SleepResponse, U32, Min>,
new: Option<SleepResponse>,
sleep_heap: &mut BinaryHeap<SleepRequest, U32, Min>,
new: Option<SleepRequest>,
) {
// If there's a sleep request ongoing now, grab it.
if let Some(current) = ticktimer.stop_interrupt() {
#[cfg(feature = "debug-print")]
info!("TickTimer: Existing request was {:?}", current);
sleep_heap.push(current).expect("couldn't push to heap")
} else {
#[cfg(feature = "debug-print")]
info!("TickTimer: There was no existing request");
}
if let Some(response) = new {
// If we have a new sleep request, add it to the heap.
if let Some(mut request) = new {
#[cfg(feature = "debug-print")]
info!("TickTimer: New sleep request was: {:?}", request);
request.msec += ticktimer.elapsed_ms() as i64;
#[cfg(feature = "debug-print")]
info!("TickTimer: Modified, the request was: {:?}", request);
sleep_heap
.push(response)
.push(request)
.expect("couldn't push new sleep to heap");
} else {
#[cfg(feature = "debug-print")]
info!("TickTimer: No new sleep request");
}
// If there are items in the sleep heap, take the next item that will expire.
if let Some(next_response) = sleep_heap.pop() {
info!("scheduling a response at {}", next_response.msec);
ticktimer.schedule_response(next_response.msec, next_response.sender);
#[cfg(feature = "debug-print")]
info!(
"TickTimer: scheduling a response at {} to {} (heap: {:?})",
next_response.msec, next_response.sender, sleep_heap
);
ticktimer.schedule_response(next_response);
}
}
@ -307,12 +400,11 @@ fn xmain() -> ! {
// Start the OS timer which is responsible for setting up preemption.
os_timer::init();
let mut sleep_heap: BinaryHeap<SleepRequest, U32, Min> = BinaryHeap::new();
log_server::init_wait().unwrap();
info!("TICKTIMER: my PID is {}", xous::process::id());
// "Sleep" commands get put in here and are ordered as necessary
let mut sleep_heap: BinaryHeap<SleepResponse, U32, Min> = BinaryHeap::new();
let ticktimer_server = xous::create_server_with_address(b"ticktimer-server")
.expect("Couldn't create Ticktimer server");
info!("TICKTIMER: Server started with SID {:?}", ticktimer_server);
@ -326,40 +418,38 @@ fn xmain() -> ! {
ticktimer.reset(); // make sure the time starts from zero
loop {
#[cfg(feature = "watchdog")]
ticktimer.reset_wdt();
//info!("TickTimer: waiting for message");
let envelope = xous::receive_message(ticktimer_server).unwrap();
//info!("TickTimer: Message: {:?}", envelope);
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
//info!("TickTimer: Opcode: {:?}", opcode);
// info!("TickTimer: Opcode: {:?}", opcode);
match opcode {
/*Opcode::Reset => {
info!("TickTimer: reset called");
ticktimer.reset();
}*/
Opcode::ElapsedMs => {
let time = ticktimer.elapsed_ms();
//info!("TickTimer: returning time of {:?}", time);
let time = ticktimer.elapsed_ms() as i64;
xous::return_scalar2(
envelope.sender,
(time & 0xFFFF_FFFFu64) as usize,
((time >> 32) & 0xFFF_FFFFu64) as usize,
(time & 0xFFFF_FFFFi64) as usize,
((time >> 32) & 0xFFF_FFFFi64) as usize,
)
.expect("TickTimer: couldn't return time request");
//info!("TickTimer: done returning value");
}
Opcode::SleepMs(ms) => recalculate_sleep(
&mut ticktimer,
&mut sleep_heap,
Some(SleepResponse {
msec: ms,
sender: envelope.sender,
}),
),
Opcode::SleepMs(ms) => {
recalculate_sleep(
&mut ticktimer,
&mut sleep_heap,
Some(SleepRequest {
msec: ms as i64,
sender: envelope.sender,
}),
);
}
Opcode::RecalculateSleep => {
recalculate_sleep(&mut ticktimer, &mut sleep_heap, None);
//info!("TickTimer: Done recalculating");
}
}
} else {

View file

@ -38,7 +38,7 @@ pub fn init() {
))
.expect("timer: couldn't claim interrupt");
let ms = 100; // tick every 100 ms
let ms = 10; // tick every 10 ms
en(false);
load((SYSTEM_CLOCK_FREQUENCY / 1_000) * ms);
reload((SYSTEM_CLOCK_FREQUENCY / 1_000) * ms);

View file

@ -16,6 +16,7 @@ pub const SERVER_NAME_STATUS: &str = "_Status bar manager_";
pub const SERVER_NAME_IME_FRONT: &str = "_IME front end_";
pub const SERVER_NAME_IME_PLUGIN_SHELL: &str = "_IME shell plugin_";
pub const SERVER_NAME_SHELLCHAT: &str = "_Shell chat application_";
pub const SERVER_NAME_RTC: &str = "_Real time clock application server_";
pub const SERVER_NAME_FCCAGENT: &str = "_Agent for EMC Testing_";
pub const SERVER_NAME_BENCHMARK: &str= "_Benchmark target_";

View file

@ -1,5 +1,5 @@
pub fn id() -> u32 {
if let Ok(crate::Result::ProcessID(pid)) = crate::syscall::current_pid() {
if let Ok(pid) = crate::syscall::current_pid() {
pid.get() as u32
} else {
0

View file

@ -1,7 +1,7 @@
use crate::{
pid_from_usize, CpuID, Error, MemoryAddress, MemoryFlags, MemoryMessage, MemoryRange,
MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessArgs, ProcessInit,
Result, ScalarMessage, SysCallResult, ThreadInit, CID, PID, SID,
Result, ScalarMessage, SysCallResult, ThreadInit, CID, PID, SID, TID,
};
use core::convert::TryInto;
@ -461,8 +461,9 @@ impl SysCall {
0,
]
}
SysCall::CreateServerId =>
[SysCallNumber::CreateServerId as usize, 0, 0, 0, 0, 0, 0, 0],
SysCall::CreateServerId => {
[SysCallNumber::CreateServerId as usize, 0, 0, 0, 0, 0, 0, 0]
}
SysCall::ReturnToParent(a1, a2) => [
SysCallNumber::ReturnToParent as usize,
a1.get() as usize,
@ -678,24 +679,8 @@ impl SysCall {
0,
0,
],
SysCall::GetThreadId => [SysCallNumber::GetThreadId as usize,
0,
0,
0,
0,
0,
0,
0,
],
SysCall::GetProcessId => [SysCallNumber::GetProcessId as usize,
0,
0,
0,
0,
0,
0,
0,
],
SysCall::GetThreadId => [SysCallNumber::GetThreadId as usize, 0, 0, 0, 0, 0, 0, 0],
SysCall::GetProcessId => [SysCallNumber::GetProcessId as usize, 0, 0, 0, 0, 0, 0, 0],
SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [
SysCallNumber::Invalid as usize,
*a1,
@ -905,7 +890,10 @@ impl SysCall {
pub fn has_memory(&self) -> bool {
match self {
SysCall::TrySendMessage(_, msg) | SysCall::SendMessage(_, msg) => {
matches!(msg, Message::Move(_) | Message::Borrow(_) | Message::MutableBorrow(_))
matches!(
msg,
Message::Move(_) | Message::Borrow(_) | Message::MutableBorrow(_)
)
}
SysCall::ReturnMemory(_, _) => true,
_ => false,
@ -963,13 +951,16 @@ impl SysCall {
/// Returns `true` if the given syscall may be called from an IRQ context
pub fn can_call_from_interrupt(&self) -> bool {
matches!(self, SysCall::TrySendMessage(_, _)
| SysCall::TryConnect(_)
| SysCall::TryReceiveMessage(_)
| SysCall::ReturnToParent(_, _)
| SysCall::ReturnScalar2(_, _, _)
| SysCall::ReturnScalar1(_, _)
| SysCall::ReturnMemory(_, _))
matches!(
self,
SysCall::TrySendMessage(_, _)
| SysCall::TryConnect(_)
| SysCall::TryReceiveMessage(_)
| SysCall::ReturnToParent(_, _)
| SysCall::ReturnScalar2(_, _, _)
| SysCall::ReturnScalar1(_, _)
| SysCall::ReturnMemory(_, _)
)
}
}
@ -1406,10 +1397,10 @@ pub fn wait_process(joiner: crate::arch::ProcessHandle) -> SysCallResult {
}
/// Get the current process ID
pub fn current_pid() -> SysCallResult {
pub fn current_pid() -> core::result::Result<PID, Error> {
rsyscall(SysCall::GetProcessId).and_then(|result| {
if let Result::ProcessID(pid) = result {
Ok(Result::ProcessID(pid))
Ok(pid)
} else {
Err(Error::InternalError)
}
@ -1417,10 +1408,10 @@ pub fn current_pid() -> SysCallResult {
}
/// Get the current thread ID
pub fn current_tid() -> SysCallResult {
rsyscall(SysCall::GetProcessId).and_then(|result| {
pub fn current_tid() -> core::result::Result<TID, Error> {
rsyscall(SysCall::GetThreadId).and_then(|result| {
if let Result::ThreadID(tid) = result {
Ok(Result::ThreadID(tid))
Ok(tid)
} else {
Err(Error::InternalError)
}

View file

@ -74,7 +74,7 @@ fn try_main() -> Result<(), DynError> {
let task = env::args().nth(1);
match task.as_deref() {
Some("renode-image") => renode_image(false, &hw_pkgs)?,
Some("renode-test") => renode_image(false, &["kernel-test"])?,
Some("renode-test") => renode_image(false, &["ticktimer-server", "log-server", "xous-names", "kernel-test"])?,
Some("renode-image-debug") => renode_image(true, &hw_pkgs)?,
Some("run") => run(false)?,
Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs)?,