mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
Merge branch 'fix-messages'
This commit is contained in:
commit
e894dbd7b8
31 changed files with 1416 additions and 955 deletions
17
Cargo.lock
generated
17
Cargo.lock
generated
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
]
|
||||
|
||||
|
|
|
|||
|
|
@ -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: _ =>
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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"]
|
||||
|
||||
|
|
|
|||
|
|
@ -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| {
|
||||
|
|
|
|||
|
|
@ -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!();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)?;
|
||||
|
|
|
|||
|
|
@ -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| {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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 = []
|
||||
|
|
|
|||
|
|
@ -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
22
services/rtc/Cargo.toml
Normal 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
73
services/rtc/src/api.rs
Normal 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
22
services/rtc/src/lib.rs
Normal 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
404
services/rtc/src/main.rs
Normal 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");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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"]
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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_";
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)?,
|
||||
|
|
|
|||
Loading…
Reference in a new issue