mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-18 08:52:45 +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"
|
name = "kernel-test"
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
|
"log",
|
||||||
|
"log-server",
|
||||||
|
"ticktimer-server",
|
||||||
"utralib",
|
"utralib",
|
||||||
"xous",
|
"xous",
|
||||||
]
|
]
|
||||||
|
|
@ -1072,6 +1075,20 @@ dependencies = [
|
||||||
"syn 1.0.60",
|
"syn 1.0.60",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "rtc"
|
||||||
|
version = "0.1.0"
|
||||||
|
dependencies = [
|
||||||
|
"bitflags",
|
||||||
|
"heapless",
|
||||||
|
"log",
|
||||||
|
"log-server",
|
||||||
|
"ticktimer-server",
|
||||||
|
"utralib",
|
||||||
|
"xous",
|
||||||
|
"xous-names",
|
||||||
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "rustc-hash"
|
name = "rustc-hash"
|
||||||
version = "1.1.0"
|
version = "1.1.0"
|
||||||
|
|
|
||||||
|
|
@ -27,6 +27,7 @@ members = [
|
||||||
"services/ime-plugin-api",
|
"services/ime-plugin-api",
|
||||||
"services/content-plugin-api",
|
"services/content-plugin-api",
|
||||||
"services/llio",
|
"services/llio",
|
||||||
|
"services/rtc",
|
||||||
"services/trng-tester",
|
"services/trng-tester",
|
||||||
]
|
]
|
||||||
default-members = [
|
default-members = [
|
||||||
|
|
@ -50,6 +51,7 @@ default-members = [
|
||||||
"services/content-plugin-api",
|
"services/content-plugin-api",
|
||||||
"services/shellchat",
|
"services/shellchat",
|
||||||
"services/llio",
|
"services/llio",
|
||||||
|
"services/rtc",
|
||||||
"services/trng-tester",
|
"services/trng-tester",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -47,12 +47,16 @@ namespace Antmicro.Renode.Peripherals.Timers
|
||||||
|
|
||||||
private void UpdateInterrupts()
|
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.irqPending.Value = true;
|
||||||
}
|
}
|
||||||
this.Log(LogLevel.Noisy, "Setting IRQ: {0}", irqPending.Value);
|
this.Log(LogLevel.Noisy, "Setting IRQ: {0} because tickValue {1} >= msleepTarget {2} ({3}) and irqEnabled = {4}",
|
||||||
IRQ.Set(irqPending.Value && irqEnabled.Value);
|
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; } }
|
public long Size { get { return 0x20; } }
|
||||||
|
|
@ -88,7 +92,7 @@ namespace Antmicro.Renode.Peripherals.Timers
|
||||||
.WithValueField(0, 32, name: "MsleepTarget1", writeCallback: (_, value) =>
|
.WithValueField(0, 32, name: "MsleepTarget1", writeCallback: (_, value) =>
|
||||||
{
|
{
|
||||||
this.msleepTarget = (this.msleepTarget & 0x00000000ffffffff) | (value << 32);
|
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: _ =>
|
valueProviderCallback: _ =>
|
||||||
{
|
{
|
||||||
|
|
@ -101,7 +105,7 @@ namespace Antmicro.Renode.Peripherals.Timers
|
||||||
writeCallback: (_, value) =>
|
writeCallback: (_, value) =>
|
||||||
{
|
{
|
||||||
this.msleepTarget = (this.msleepTarget & 0xffffffff00000000) | (value & 0xffffffff);
|
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: _ =>
|
valueProviderCallback: _ =>
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -22,10 +22,11 @@ machine LoadPlatformDescription @betrusted.repl
|
||||||
machine StartGdbServer 3333 true
|
machine StartGdbServer 3333 true
|
||||||
showAnalyzer uart
|
showAnalyzer uart
|
||||||
showAnalyzer uartconsole
|
showAnalyzer uartconsole
|
||||||
showAnalyzer uartserver0
|
# showAnalyzer uartserver0
|
||||||
showAnalyzer memlcd
|
# showAnalyzer memlcd
|
||||||
|
|
||||||
logLevel -1 kbd
|
logLevel -1 kbd
|
||||||
|
# logLevel -1 ticktimer
|
||||||
|
|
||||||
# The macro `reset` gets called implicitly when running `machine Reset`
|
# The macro `reset` gets called implicitly when running `machine Reset`
|
||||||
macro reset
|
macro reset
|
||||||
|
|
|
||||||
|
|
@ -21,6 +21,7 @@ riscv = "0.5.6"
|
||||||
debug-print = []
|
debug-print = []
|
||||||
print-panics = []
|
print-panics = []
|
||||||
report-memory = ["stats_alloc"]
|
report-memory = ["stats_alloc"]
|
||||||
|
wrap-print = []
|
||||||
#default = ["print-panics", "debug-print"]
|
#default = ["print-panics", "debug-print"]
|
||||||
default = ["print-panics"]
|
default = ["print-panics"]
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -443,6 +443,7 @@ pub fn idle() -> bool {
|
||||||
};
|
};
|
||||||
let pid1 = SystemServices::with_mut(|ss| ss.create_process(pid1_init)).unwrap();
|
let pid1 = SystemServices::with_mut(|ss| ss.create_process(pid1_init)).unwrap();
|
||||||
assert_eq!(pid1.get(), 1);
|
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")
|
let listen_addr = env::var("XOUS_LISTEN_ADDR")
|
||||||
.map(|s| {
|
.map(|s| {
|
||||||
|
|
|
||||||
|
|
@ -3,14 +3,6 @@
|
||||||
|
|
||||||
use xous_kernel::{TID, PID};
|
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) {
|
pub fn enable_irq(_irq_no: usize) {
|
||||||
unimplemented!();
|
unimplemented!();
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -19,7 +19,6 @@ pub fn current_pid() -> PID {
|
||||||
|
|
||||||
pub fn init() {
|
pub fn init() {
|
||||||
unsafe {
|
unsafe {
|
||||||
sstatus::set_sie();
|
|
||||||
sie::set_ssoft();
|
sie::set_ssoft();
|
||||||
sie::set_sext();
|
sie::set_sext();
|
||||||
}
|
}
|
||||||
|
|
@ -29,6 +28,21 @@ pub fn init() {
|
||||||
/// Put the core to sleep until an interrupt hits. Returns `true`
|
/// Put the core to sleep until an interrupt hits. Returns `true`
|
||||||
/// to indicate the kernel should not exit.
|
/// to indicate the kernel should not exit.
|
||||||
pub fn idle() -> bool {
|
pub fn idle() -> bool {
|
||||||
|
|
||||||
|
// Issue `wfi`. This will return as soon as an external interrupt
|
||||||
|
// is available.
|
||||||
unsafe { riscv::asm::wfi() };
|
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
|
true
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -6,9 +6,6 @@ use core::fmt::{Error, Write};
|
||||||
#[cfg(baremetal)]
|
#[cfg(baremetal)]
|
||||||
use utralib::generated::*;
|
use utralib::generated::*;
|
||||||
|
|
||||||
#[allow(dead_code)] // this is unused in hosted mode, kill the warning
|
|
||||||
static mut INITIALIZED: bool = false;
|
|
||||||
|
|
||||||
#[macro_use]
|
#[macro_use]
|
||||||
#[cfg(all(
|
#[cfg(all(
|
||||||
not(test),
|
not(test),
|
||||||
|
|
@ -66,6 +63,11 @@ macro_rules! println
|
||||||
pub struct Uart {
|
pub struct Uart {
|
||||||
// pub base: *mut usize,
|
// 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)]
|
#[cfg(baremetal)]
|
||||||
impl Uart {
|
impl Uart {
|
||||||
|
|
@ -86,6 +88,23 @@ impl Uart {
|
||||||
while uart_csr.r(utra::uart::TXFULL) != 0 {
|
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);
|
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.
|
// Unsafe is required since we're accessing a static mut array.
|
||||||
// However, we disable interrupts to prevent contention on this array.
|
// However, we disable interrupts to prevent contention on this array.
|
||||||
unsafe {
|
unsafe {
|
||||||
arch::irq::disable_all_irqs();
|
|
||||||
let result = if irq > IRQ_HANDLERS.len() {
|
let result = if irq > IRQ_HANDLERS.len() {
|
||||||
Err(xous_kernel::Error::InterruptNotFound)
|
Err(xous_kernel::Error::InterruptNotFound)
|
||||||
} else if IRQ_HANDLERS[irq].is_some() {
|
} else if IRQ_HANDLERS[irq].is_some() {
|
||||||
|
|
@ -63,7 +62,6 @@ pub fn interrupt_claim(
|
||||||
arch::irq::enable_irq(irq);
|
arch::irq::enable_irq(irq);
|
||||||
Ok(())
|
Ok(())
|
||||||
};
|
};
|
||||||
arch::irq::enable_all_irqs();
|
|
||||||
result
|
result
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -153,9 +153,7 @@ pub extern "C" fn kmain() {
|
||||||
}
|
}
|
||||||
|
|
||||||
loop {
|
loop {
|
||||||
arch::irq::disable_all_irqs();
|
|
||||||
pid = next_pid_to_run(pid);
|
pid = next_pid_to_run(pid);
|
||||||
arch::irq::enable_all_irqs();
|
|
||||||
|
|
||||||
match pid {
|
match pid {
|
||||||
Some(pid) => {
|
Some(pid) => {
|
||||||
|
|
@ -170,8 +168,10 @@ pub extern "C" fn kmain() {
|
||||||
|
|
||||||
#[cfg(feature = "debug-print")]
|
#[cfg(feature = "debug-print")]
|
||||||
SystemServices::with(|system_services| {
|
SystemServices::with(|system_services| {
|
||||||
for test_idx in 0..system_services.processes.len() {
|
for (test_idx, process) in system_services.processes.iter().enumerate() {
|
||||||
println!("{:?}", system_services.processes[test_idx]);
|
if ! process.free() {
|
||||||
|
println!("PID {}: {:?}", test_idx + 1, process);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -387,17 +387,26 @@ impl Server {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
*current_val = QueuedMessage::Empty;
|
*current_val = QueuedMessage::Empty;
|
||||||
self.queue_tail += 1;
|
if idx == self.queue_tail {
|
||||||
if self.queue_tail >= self.queue.len() {
|
self.queue_tail += 1;
|
||||||
self.queue_tail = 0;
|
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
|
// Destructure the PID and context ID from the `pid_tid` field
|
||||||
klog!(
|
// klog!(
|
||||||
"taking waiting message and returning to pid: {} tid: {}",
|
// "taking waiting message and returning to pid: {} tid: {}",
|
||||||
pid,
|
// pid,
|
||||||
tid
|
// tid
|
||||||
);
|
// );
|
||||||
|
|
||||||
if !is_memory {
|
if !is_memory {
|
||||||
return Ok(WaitingMessage::ScalarMessage(
|
return Ok(WaitingMessage::ScalarMessage(
|
||||||
|
|
@ -442,219 +451,259 @@ impl Server {
|
||||||
/// * **None**: There are no waiting messages
|
/// * **None**: There are no waiting messages
|
||||||
/// ***Some(MessageEnvelope): This message is queued.
|
/// ***Some(MessageEnvelope): This message is queued.
|
||||||
pub fn take_next_message(&mut self, sidx: usize) -> Option<xous_kernel::MessageEnvelope> {
|
pub fn take_next_message(&mut self, sidx: usize) -> Option<xous_kernel::MessageEnvelope> {
|
||||||
// println!(
|
// klog!(
|
||||||
// "queue_head: ((({}))) queue_tail: ((({}))): {:?} CID: ((({})))",
|
// "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;
|
use core::convert::TryInto;
|
||||||
let mut sender = SenderID::new(sidx, self.queue_tail, None);
|
let mut queue_idx = self.queue_tail;
|
||||||
let (result, response) = match self.queue[self.queue_tail] {
|
while queue_idx != self.queue_head {
|
||||||
QueuedMessage::Empty => return None,
|
let mut sender = SenderID::new(sidx, queue_idx, None);
|
||||||
QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => return None,
|
// klog!("Message @ server.queue[{}]: {:?}", queue_idx, self.queue[queue_idx]);
|
||||||
QueuedMessage::WaitingForget(_, _, _, _, _) => return None,
|
let (result, response) = match self.queue[queue_idx] {
|
||||||
QueuedMessage::WaitingReturnScalar(_, _, _) => return None,
|
QueuedMessage::Empty => {
|
||||||
QueuedMessage::MemoryMessageROLend(
|
queue_idx += 1;
|
||||||
pid,
|
if queue_idx >= self.queue.len() {
|
||||||
tid,
|
queue_idx = 0;
|
||||||
client_addr,
|
}
|
||||||
id,
|
continue;
|
||||||
buf,
|
}
|
||||||
buf_size,
|
QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => {
|
||||||
offset,
|
queue_idx += 1;
|
||||||
valid,
|
if queue_idx >= self.queue.len() {
|
||||||
) => {
|
queue_idx = 0;
|
||||||
sender.pid = PID::new(pid.try_into().unwrap());
|
}
|
||||||
(
|
continue;
|
||||||
xous_kernel::MessageEnvelope {
|
}
|
||||||
sender: sender.into(),
|
QueuedMessage::WaitingForget(_, _, _, _, _) => {
|
||||||
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
queue_idx += 1;
|
||||||
id,
|
if queue_idx >= self.queue.len() {
|
||||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
queue_idx = 0;
|
||||||
offset: MemorySize::new(offset),
|
}
|
||||||
valid: MemorySize::new(valid),
|
continue;
|
||||||
}),
|
}
|
||||||
},
|
QueuedMessage::WaitingReturnScalar(_, _, _) => {
|
||||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
queue_idx += 1;
|
||||||
)
|
if queue_idx >= self.queue.len() {
|
||||||
}
|
queue_idx = 0;
|
||||||
QueuedMessage::MemoryMessageRWLend(
|
}
|
||||||
pid,
|
continue;
|
||||||
tid,
|
}
|
||||||
client_addr,
|
QueuedMessage::MemoryMessageROLend(
|
||||||
id,
|
pid,
|
||||||
buf,
|
tid,
|
||||||
buf_size,
|
client_addr,
|
||||||
offset,
|
id,
|
||||||
valid,
|
buf,
|
||||||
) => {
|
buf_size,
|
||||||
sender.pid = PID::new(pid.try_into().unwrap());
|
offset,
|
||||||
(
|
valid,
|
||||||
xous_kernel::MessageEnvelope {
|
) => {
|
||||||
sender: sender.into(),
|
sender.pid = PID::new(pid.try_into().unwrap());
|
||||||
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
|
(
|
||||||
id,
|
xous_kernel::MessageEnvelope {
|
||||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
sender: sender.into(),
|
||||||
offset: MemorySize::new(offset),
|
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
||||||
valid: MemorySize::new(valid),
|
id,
|
||||||
}),
|
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||||
},
|
offset: MemorySize::new(offset),
|
||||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
valid: MemorySize::new(valid),
|
||||||
)
|
}),
|
||||||
}
|
},
|
||||||
QueuedMessage::MemoryMessageROLendTerminated(
|
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||||
pid,
|
)
|
||||||
tid,
|
}
|
||||||
client_addr,
|
QueuedMessage::MemoryMessageRWLend(
|
||||||
id,
|
pid,
|
||||||
buf,
|
tid,
|
||||||
buf_size,
|
client_addr,
|
||||||
offset,
|
id,
|
||||||
valid,
|
buf,
|
||||||
) => {
|
buf_size,
|
||||||
sender.pid = PID::new(pid.try_into().unwrap());
|
offset,
|
||||||
(
|
valid,
|
||||||
xous_kernel::MessageEnvelope {
|
) => {
|
||||||
sender: sender.into(),
|
sender.pid = PID::new(pid.try_into().unwrap());
|
||||||
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
(
|
||||||
id,
|
xous_kernel::MessageEnvelope {
|
||||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
sender: sender.into(),
|
||||||
offset: MemorySize::new(offset),
|
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
|
||||||
valid: MemorySize::new(valid),
|
id,
|
||||||
}),
|
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||||
},
|
offset: MemorySize::new(offset),
|
||||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
valid: MemorySize::new(valid),
|
||||||
)
|
}),
|
||||||
}
|
},
|
||||||
QueuedMessage::MemoryMessageRWLendTerminated(
|
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||||
pid,
|
)
|
||||||
tid,
|
}
|
||||||
client_addr,
|
QueuedMessage::MemoryMessageROLendTerminated(
|
||||||
id,
|
pid,
|
||||||
buf,
|
tid,
|
||||||
buf_size,
|
client_addr,
|
||||||
offset,
|
id,
|
||||||
valid,
|
buf,
|
||||||
) => {
|
buf_size,
|
||||||
sender.pid = PID::new(pid.try_into().unwrap());
|
offset,
|
||||||
(
|
valid,
|
||||||
xous_kernel::MessageEnvelope {
|
) => {
|
||||||
sender: sender.into(),
|
sender.pid = PID::new(pid.try_into().unwrap());
|
||||||
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
|
(
|
||||||
id,
|
xous_kernel::MessageEnvelope {
|
||||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
sender: sender.into(),
|
||||||
offset: MemorySize::new(offset),
|
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
||||||
valid: MemorySize::new(valid),
|
id,
|
||||||
}),
|
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||||
},
|
offset: MemorySize::new(offset),
|
||||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
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(
|
QueuedMessage::BlockingScalarMessage(
|
||||||
pid,
|
pid,
|
||||||
tid,
|
tid,
|
||||||
client_addr,
|
client_addr,
|
||||||
id,
|
id,
|
||||||
arg1,
|
arg1,
|
||||||
arg2,
|
arg2,
|
||||||
arg3,
|
arg3,
|
||||||
arg4,
|
arg4,
|
||||||
) => {
|
) => {
|
||||||
sender.pid = PID::new(pid.try_into().unwrap());
|
sender.pid = PID::new(pid.try_into().unwrap());
|
||||||
(
|
(
|
||||||
xous_kernel::MessageEnvelope {
|
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(),
|
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,
|
id,
|
||||||
arg1,
|
arg1,
|
||||||
arg2,
|
arg2,
|
||||||
arg3,
|
arg3,
|
||||||
arg4,
|
arg4,
|
||||||
}),
|
}),
|
||||||
},
|
};
|
||||||
QueuedMessage::WaitingReturnScalar(pid, tid, client_addr),
|
self.queue[queue_idx] = QueuedMessage::Empty;
|
||||||
)
|
if queue_idx == self.queue_tail {
|
||||||
}
|
self.queue_tail += 1;
|
||||||
QueuedMessage::MemoryMessageSend(
|
if self.queue_tail >= self.queue.len() {
|
||||||
pid,
|
self.queue_tail = 0;
|
||||||
_tid,
|
}
|
||||||
_reserved,
|
}
|
||||||
id,
|
return Some(msg);
|
||||||
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;
|
|
||||||
}
|
}
|
||||||
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
|
self.queue[queue_idx] = response;
|
||||||
QueuedMessage::ScalarMessage(pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => {
|
return Some(result);
|
||||||
sender.pid = PID::new(pid.try_into().unwrap());
|
}
|
||||||
let msg = xous_kernel::MessageEnvelope {
|
None
|
||||||
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)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Add the given message to this server's queue.
|
/// Add the given message to this server's queue.
|
||||||
|
|
@ -669,7 +718,12 @@ impl Server {
|
||||||
message: xous_kernel::Message,
|
message: xous_kernel::Message,
|
||||||
original_address: Option<MemoryAddress>,
|
original_address: Option<MemoryAddress>,
|
||||||
) -> core::result::Result<usize, xous_kernel::Error> {
|
) -> 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 {
|
if self.queue[self.queue_head] != QueuedMessage::Empty {
|
||||||
return Err(xous_kernel::Error::ServerQueueFull);
|
return Err(xous_kernel::Error::ServerQueueFull);
|
||||||
}
|
}
|
||||||
|
|
@ -732,6 +786,11 @@ impl Server {
|
||||||
if self.queue_head >= self.queue.len() {
|
if self.queue_head >= self.queue.len() {
|
||||||
self.queue_head = 0;
|
self.queue_head = 0;
|
||||||
}
|
}
|
||||||
|
// klog!(
|
||||||
|
// "queue head: {} queue_tail: {}",
|
||||||
|
// self.queue_head,
|
||||||
|
// self.queue_tail
|
||||||
|
// );
|
||||||
Ok(idx)
|
Ok(idx)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -717,7 +717,7 @@ impl SystemServices {
|
||||||
/// If the current process is not running.
|
/// If the current process is not running.
|
||||||
pub fn switch_from_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> {
|
pub fn switch_from_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> {
|
||||||
let process = self.get_process_mut(pid)?;
|
let process = self.get_process_mut(pid)?;
|
||||||
// println!(
|
// klog!(
|
||||||
// "switch_from_thread({}:{}): Old state was {:?}",
|
// "switch_from_thread({}:{}): Old state was {:?}",
|
||||||
// pid, tid, process.state
|
// pid, tid, process.state
|
||||||
// );
|
// );
|
||||||
|
|
@ -750,7 +750,7 @@ impl SystemServices {
|
||||||
);
|
);
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
// println!(
|
// klog!(
|
||||||
// "switch_from_thread({}:{}): New state is {:?}",
|
// "switch_from_thread({}:{}): New state is {:?}",
|
||||||
// pid, tid, process.state
|
// pid, tid, process.state
|
||||||
// );
|
// );
|
||||||
|
|
@ -810,14 +810,12 @@ impl SystemServices {
|
||||||
) -> Result<TID, xous_kernel::Error> {
|
) -> Result<TID, xous_kernel::Error> {
|
||||||
let previous_pid = self.current_pid();
|
let previous_pid = self.current_pid();
|
||||||
|
|
||||||
let debug = false;
|
if new_tid != 0 {
|
||||||
if debug {
|
klog!("Activating process {} thread {}", new_pid, new_tid);
|
||||||
println!(
|
} else {
|
||||||
"\n\r KERNEL({},{}): Activating process {} thread {}",
|
klog!("Activating process {} thread ANY", new_pid);
|
||||||
previous_pid, previous_tid, new_pid, new_tid
|
|
||||||
);
|
|
||||||
//ArchProcess::with_current(|current| current.print_thread());
|
|
||||||
}
|
}
|
||||||
|
//ArchProcess::with_current(|current| current.print_thread());
|
||||||
|
|
||||||
// Save state if the PID has changed. This will activate the new memory
|
// Save state if the PID has changed. This will activate the new memory
|
||||||
// space.
|
// space.
|
||||||
|
|
@ -854,13 +852,15 @@ impl SystemServices {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
new.current_thread = new_tid as _;
|
new.current_thread = new_tid as _;
|
||||||
// println!(" -- picked thread {}", new_tid);
|
klog!("picked thread ID {}", new_tid);
|
||||||
} else if x & (1 << new_tid) == 0 {
|
} else if x & (1 << new_tid) == 0 {
|
||||||
// println!(
|
// println!(
|
||||||
// "thread is {:?}, which is not valid for new thread {}",
|
// "thread is {:?}, which is not valid for new thread {}",
|
||||||
// new.state, new_tid
|
// new.state, new_tid
|
||||||
// );
|
// );
|
||||||
return Err(xous_kernel::Error::ProcessNotFound);
|
return Err(xous_kernel::Error::ProcessNotFound);
|
||||||
|
} else {
|
||||||
|
new.current_thread = new_tid as _;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
ProcessState::Sleeping => {
|
ProcessState::Sleeping => {
|
||||||
|
|
@ -874,8 +874,8 @@ impl SystemServices {
|
||||||
// if we encounter an error.
|
// if we encounter an error.
|
||||||
new.mapping.activate()?;
|
new.mapping.activate()?;
|
||||||
|
|
||||||
// Set up the new process, if necessary. Remove the new context from
|
// Set up the new process, if necessary. Remove the new thread from
|
||||||
// the list of ready contexts.
|
// the list of ready threads.
|
||||||
new.state = match new.state {
|
new.state = match new.state {
|
||||||
ProcessState::Setup(thread_init) => {
|
ProcessState::Setup(thread_init) => {
|
||||||
// println!("Setting up new process...");
|
// println!("Setting up new process...");
|
||||||
|
|
@ -902,14 +902,16 @@ impl SystemServices {
|
||||||
let previous = self
|
let previous = self
|
||||||
.get_process_mut(previous_pid)
|
.get_process_mut(previous_pid)
|
||||||
.expect("couldn't get 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 {
|
previous.state = match previous.state {
|
||||||
// If the previous process had exactly one thread that can be
|
// If the previous process had exactly one thread that can be
|
||||||
// run, then the Running thread list will be 0. In that case,
|
// run, then the Running thread list will be 0. In that case,
|
||||||
// we will either need to Sleep this process, or mark it as
|
// we will either need to Sleep this process, or mark it as
|
||||||
// being Ready to run.
|
// being Ready to run.
|
||||||
ProcessState::Running(x) if x == 0 => {
|
ProcessState::Running(x) if x == 0 => {
|
||||||
if can_resume /*|| advance_thread*/ {
|
if can_resume
|
||||||
|
/*|| advance_thread*/
|
||||||
|
{
|
||||||
ProcessState::Ready(1 << previous_tid)
|
ProcessState::Ready(1 << previous_tid)
|
||||||
} else {
|
} else {
|
||||||
ProcessState::Sleeping
|
ProcessState::Sleeping
|
||||||
|
|
@ -930,17 +932,18 @@ impl SystemServices {
|
||||||
previous_pid, other
|
previous_pid, other
|
||||||
),
|
),
|
||||||
};
|
};
|
||||||
if debug {println!(" KERNEL|STATE: state change from {:?} -> {:?}", _oldstate, previous.state);}
|
klog!(
|
||||||
// if advance_thread {
|
"PID {:?} state change from {:?} -> {:?}",
|
||||||
// previous.current_thread += 1;
|
previous_pid,
|
||||||
// if previous.current_thread as TID > arch::process::MAX_CONTEXT {
|
_oldstate,
|
||||||
// previous.current_thread = 0;
|
previous.state
|
||||||
// }
|
);
|
||||||
// }
|
// klog!(
|
||||||
// println!(
|
// "Set previous process PID {} state to {:?} (with can_resume = {})",
|
||||||
// "Set previous process PID {} state to {:?} (with can_resume = {})",
|
// previous_pid,
|
||||||
// previous_pid, previous.state, can_resume
|
// previous.state,
|
||||||
// );
|
// can_resume
|
||||||
|
// );
|
||||||
} else {
|
} else {
|
||||||
let new = self.get_process_mut(new_pid)?;
|
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
|
// Mark the previous TID as being runnable, and remove the new TID
|
||||||
// from the list of threads that can be run.
|
// 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 {
|
} else {
|
||||||
panic!(
|
panic!(
|
||||||
"PID {} invalid process state (not Running): {:?}",
|
"PID {} invalid process state (not Running): {:?}",
|
||||||
|
|
@ -1390,23 +1395,34 @@ impl SystemServices {
|
||||||
/// queue.
|
/// queue.
|
||||||
/// * **ServerNotFound**: The server queue was full and a free slot could not
|
/// * **ServerNotFound**: The server queue was full and a free slot could not
|
||||||
/// be found.
|
/// be found.
|
||||||
pub fn create_server(
|
pub fn create_server(&mut self, pid: PID) -> Result<(SID, CID), xous_kernel::Error> {
|
||||||
&mut self,
|
let sid = SID::from_u32(
|
||||||
pid: PID,
|
arch::rand::get_u32(),
|
||||||
) -> Result<(SID, CID), xous_kernel::Error> {
|
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());
|
arch::rand::get_u32(),
|
||||||
|
arch::rand::get_u32(),
|
||||||
|
);
|
||||||
self.create_server_with_address(pid, sid)
|
self.create_server_with_address(pid, sid)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Generate a random server ID and return it to the caller. Doesn't create
|
/// Generate a random server ID and return it to the caller. Doesn't create
|
||||||
/// any processes.
|
/// any processes.
|
||||||
pub fn create_server_id(&mut self) -> Result<SID, xous_kernel::Error> {
|
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)
|
Ok(sid)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Connect to a server on behalf of another process.
|
/// 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 original_pid = crate::arch::process::current_pid();
|
||||||
|
|
||||||
let process = self.get_process_mut(target_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
|
let sidx = ss
|
||||||
.sidx_from_cid(cid)
|
.sidx_from_cid(cid)
|
||||||
.ok_or(xous_kernel::Error::ServerNotFound)?;
|
.ok_or(xous_kernel::Error::ServerNotFound)?;
|
||||||
// ::debug_here::debug_here!();
|
|
||||||
|
|
||||||
let server_pid = ss
|
let server_pid = ss
|
||||||
.server_from_sidx(sidx)
|
.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.
|
// transfer it right away.
|
||||||
if let Some(server_tid) = ss
|
if let Some(server_tid) = ss
|
||||||
.server_from_sidx_mut(sidx)
|
.server_from_sidx_mut(sidx)
|
||||||
.expect("server couldn't be located")
|
.expect("server couldn't be located")
|
||||||
.take_available_thread()
|
.take_available_thread()
|
||||||
{
|
{
|
||||||
klog!(
|
// klog!(
|
||||||
"there are contexts available to handle this message -- marking PID {} as Ready",
|
// "there are threads available in PID {} to handle this message -- marking as Ready",
|
||||||
server_pid
|
// server_pid
|
||||||
);
|
// );
|
||||||
let sender_idx = if message.is_blocking() {
|
let sender_idx = if message.is_blocking() {
|
||||||
ss.remember_server_message(sidx, pid, thread, &message, client_address)
|
ss.remember_server_message(sidx, pid, thread, &message, client_address)
|
||||||
.map_err(|e| {
|
.map_err(|e| {
|
||||||
|
klog!("error remembering server message: {:?}", e);
|
||||||
ss.server_from_sidx_mut(sidx)
|
ss.server_from_sidx_mut(sidx)
|
||||||
.expect("server couldn't be located")
|
.expect("server couldn't be located")
|
||||||
.return_available_thread(thread);
|
.return_available_thread(thread);
|
||||||
|
|
@ -184,12 +184,12 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
|
||||||
})?;
|
})?;
|
||||||
|
|
||||||
if blocking && cfg!(baremetal) {
|
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)
|
ss.activate_process_thread(thread, server_pid, server_tid, !blocking)
|
||||||
.map(|_| Ok(xous_kernel::Result::Message(envelope)))
|
.map(|_| Ok(xous_kernel::Result::Message(envelope)))
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
||||||
} else if blocking && !cfg!(baremetal) {
|
} 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_from_thread(pid, thread)?;
|
||||||
ss.switch_to_thread(server_pid, Some(server_tid))?;
|
ss.switch_to_thread(server_pid, Some(server_tid))?;
|
||||||
ss.set_thread_result(
|
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)
|
.map(|_| xous_kernel::Result::BlockedProcess)
|
||||||
} else if cfg!(baremetal) {
|
} 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(
|
ss.set_thread_result(
|
||||||
server_pid,
|
server_pid,
|
||||||
server_tid,
|
server_tid,
|
||||||
|
|
@ -223,7 +224,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
klog!(
|
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
|
server_pid
|
||||||
);
|
);
|
||||||
// Add this message to the queue. If the queue is full, this
|
// 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)
|
Ok(xous_kernel::Result::ResumeProcess)
|
||||||
}
|
}
|
||||||
SysCall::ReceiveMessage(sid) => receive_message(pid, tid, sid, ExecutionType::Blocking),
|
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| {
|
SysCall::WaitEvent => SystemServices::with_mut(|ss| {
|
||||||
let process = ss.get_process(pid).expect("Can't get current process");
|
let process = ss.get_process(pid).expect("Can't get current process");
|
||||||
let ppid = process.ppid;
|
let ppid = process.ppid;
|
||||||
unsafe { SWITCHTO_CALLER = None };
|
unsafe { SWITCHTO_CALLER = None };
|
||||||
// TODO: Advance thread
|
// TODO: Advance thread
|
||||||
ss.activate_process_thread(tid, ppid, 0, false)
|
if cfg!(baremetal) {
|
||||||
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
ss.activate_process_thread(tid, ppid, 0, false)
|
||||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
.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| {
|
SysCall::CreateThread(thread_init) => SystemServices::with_mut(|ss| {
|
||||||
ss.create_thread(pid, thread_init).map(|new_tid| {
|
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| {
|
SysCall::CreateServerId => SystemServices::with_mut(|ss| {
|
||||||
ss.create_server_id()
|
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| {
|
SysCall::TryConnect(sid) => SystemServices::with_mut(|ss| {
|
||||||
ss.connect_to_server(sid)
|
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 => {
|
SysCall::Shutdown => {
|
||||||
SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok))
|
SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok))
|
||||||
}
|
}
|
||||||
SysCall::GetProcessId => {
|
SysCall::GetProcessId => Ok(xous_kernel::Result::ProcessID(pid)),
|
||||||
Ok(xous_kernel::Result::ProcessID(pid))
|
SysCall::GetThreadId => Ok(xous_kernel::Result::ThreadID(tid)),
|
||||||
}
|
|
||||||
SysCall::GetThreadId => {
|
|
||||||
Ok(xous_kernel::Result::ThreadID(tid))
|
|
||||||
}
|
|
||||||
|
|
||||||
SysCall::Connect(sid) => {
|
SysCall::Connect(sid) => {
|
||||||
let result = SystemServices::with_mut(|ss| {
|
let result = SystemServices::with_mut(|ss| {
|
||||||
|
|
|
||||||
|
|
@ -181,7 +181,7 @@ impl ModalCanvases {
|
||||||
#[xous::xous_main]
|
#[xous::xous_main]
|
||||||
fn xmain() -> ! {
|
fn xmain() -> ! {
|
||||||
let debug1 = false; // debug level 1 - most general level
|
let debug1 = false; // debug level 1 - most general level
|
||||||
let debugc = false;
|
let debugc = true;
|
||||||
log_server::init_wait().unwrap();
|
log_server::init_wait().unwrap();
|
||||||
info!("GAM: my PID is {}", xous::process::id());
|
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();
|
let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
|
||||||
info!("GAM: entering main loop");
|
info!("GAM: entering main loop");
|
||||||
loop {
|
loop {
|
||||||
let maybe_env = xous::try_receive_message(gam_sid).unwrap();
|
let envelope = xous::receive_message(gam_sid).unwrap();
|
||||||
if debug1 { if maybe_env.is_some() {info!("GAM: Message: {:?}", maybe_env);} }
|
if debug1 { info!("GAM: Message: {:?}", envelope);}
|
||||||
match maybe_env {
|
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
|
||||||
Some(envelope) => {
|
if debug1 {info!("GAM: Opcode: {:?}", opcode);}
|
||||||
if debug1 {info!("GAM: Message: {:?}", envelope); }
|
match opcode {
|
||||||
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
|
Opcode::ClearCanvas(gid) => {
|
||||||
if debug1 {info!("GAM: Opcode: {:?}", opcode);}
|
match canvases.get(&gid) {
|
||||||
match opcode {
|
Some(c) => {
|
||||||
Opcode::ClearCanvas(gid) => {
|
let mut rect = c.clip_rect();
|
||||||
match canvases.get(&gid) {
|
rect.style = DrawStyle {fill_color: Some(PixelColor::Light), stroke_color: None, stroke_width: 0,};
|
||||||
Some(c) => {
|
graphics_server::draw_rectangle(gfx_conn, rect).expect("GAM: can't clear canvas");
|
||||||
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."),
|
|
||||||
}
|
|
||||||
},
|
},
|
||||||
Opcode::GetCanvasBounds(gid) => {
|
None => info!("GAM: attempt to clear bogus canvas, ignored."),
|
||||||
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"),
|
|
||||||
}
|
}
|
||||||
} else if let xous::Message::MutableBorrow(m) = &envelope.body {
|
},
|
||||||
let mut buf = unsafe { xous::XousBuffer::from_memory_message(m) };
|
Opcode::GetCanvasBounds(gid) => {
|
||||||
let value = unsafe {
|
match canvases.get(&gid) {
|
||||||
archived_value_mut::<api::Opcode>(Pin::new(buf.as_mut()), m.id as usize)
|
Some(c) => {
|
||||||
};
|
let mut rect = c.clip_rect();
|
||||||
match &*value {
|
rect.normalize(); // normalize to 0,0 coordinates
|
||||||
rkyv::Archived::<api::Opcode>::RenderTextView(rtv) => {
|
xous::return_scalar2(envelope.sender,
|
||||||
let mut tv = rtv.deserialize(&mut xous::XousDeserializer).unwrap();
|
rect.tl.into(),
|
||||||
if debug1{info!("GAM: rendertextview {:?}", tv);}
|
rect.br.into(),
|
||||||
match tv.get_op() {
|
).expect("GAM: couldn't return canvas bounds");
|
||||||
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???
|
|
||||||
}
|
|
||||||
},
|
|
||||||
};
|
|
||||||
},
|
},
|
||||||
rkyv::Archived::<api::Opcode>::SetCanvasBounds(rcb) => {
|
None => info!("GAM: attempt to get bounds on bogus canvas gid {:?}, {:?} ignored.", gid, envelope),
|
||||||
let mut cb: SetCanvasBoundsRequest = rcb.deserialize(&mut xous::XousDeserializer).unwrap();
|
}
|
||||||
if debug1{info!("GAM: SetCanvasBoundsRequest {:?}", cb);}
|
},
|
||||||
// ASSUME:
|
Opcode::PowerDownRequest => {
|
||||||
// very few canvases allow dynamic resizing, so we special case these
|
powerdown_requested = true;
|
||||||
if cb.canvas == chatlayout.input {
|
graphics_server::draw_sleepscreen(gfx_conn).expect("GAM: couldn't draw sleep screen");
|
||||||
let newheight = chatlayout.resize_input(cb.requested.y, &mut canvases).expect("GAM: SetCanvasBoundsRequest couldn't recompute input canvas height");
|
// a screen flush is part of the draw_sleepscreen abstraction
|
||||||
cb.granted = Some(newheight);
|
xous::return_scalar(envelope.sender, 1).expect("GAM: couldn't confirm power down UI request");
|
||||||
canvases = recompute_canvases(canvases, Rectangle::new(Point::new(0, 0), screensize));
|
},
|
||||||
|
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() {
|
deface(gfx_conn, &mut canvases);
|
||||||
ccc.redraw_canvas().expect("GAM: couldn't issue redraw to content canvas");
|
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 {
|
} 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 Some(canvas) = canvases.get_mut(&tv.get_canvas_gid()) {
|
||||||
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.
|
// first, figure out if we should even be drawing to this canvas.
|
||||||
if canvas.is_drawable() {
|
if canvas.is_drawable() {
|
||||||
match obj.obj {
|
// set the clip rectangle according to the canvas' location
|
||||||
GamObjectType::Line(mut line) => {
|
tv.clip_rect = Some(canvas.clip_rect().into());
|
||||||
line.translate(canvas.clip_rect().tl);
|
|
||||||
line.translate(canvas.pan_offset());
|
// you have to clone the tv object, because if you don't the same block of
|
||||||
graphics_server::draw_line_clipped(gfx_conn,
|
// memory gets passed on to the graphics_server(). Which is efficient, but,
|
||||||
line,
|
// the call will automatically Drop() the memory, which causes a panic when
|
||||||
canvas.clip_rect(),
|
// this routine returns.
|
||||||
).expect("GAM: couldn't draw line");
|
let mut tv_clone = tv.clone();
|
||||||
},
|
// issue the draw command
|
||||||
GamObjectType::Circ(mut circ) => {
|
graphics_server::draw_textview(gfx_conn, &mut tv_clone).expect("GAM: text view draw could not complete.");
|
||||||
circ.translate(canvas.clip_rect().tl);
|
// copy back the fields that we want to be mutable
|
||||||
circ.translate(canvas.pan_offset());
|
if debug1{info!("GAM: got computed cursor of {:?}", tv_clone.cursor);}
|
||||||
graphics_server::draw_circle_clipped(gfx_conn,
|
tv.cursor = tv_clone.cursor;
|
||||||
circ,
|
tv.bounds_computed = tv_clone.bounds_computed;
|
||||||
canvas.clip_rect(),
|
|
||||||
).expect("GAM: couldn't draw circle");
|
// pack our data back into the buffer to return
|
||||||
},
|
let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf);
|
||||||
GamObjectType::Rect(mut rect) => {
|
writer.serialize_value(&api::Opcode::RenderTextView(tv)).expect("GAM: couldn't re-archive return value");
|
||||||
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");
|
canvas.do_drawn().expect("GAM: couldn't set canvas to drawn");
|
||||||
} else {
|
} 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 {
|
} 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);
|
rkyv::Archived::<api::Opcode>::SetCanvasBounds(rcb) => {
|
||||||
}
|
let mut cb: SetCanvasBoundsRequest = rcb.deserialize(&mut xous::XousDeserializer).unwrap();
|
||||||
// /*
|
if debug1{info!("GAM: SetCanvasBoundsRequest {:?}", cb);}
|
||||||
},
|
// ASSUME:
|
||||||
_ => xous::yield_slice(),
|
// very few canvases allow dynamic resizing, so we special case these
|
||||||
// envelope implements Drop(), which includes a call to syscall::return_memory(self.sender, message.buf)
|
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
|
if ccc.connection.is_some() {
|
||||||
// graphics traffic than necessary? Trying out redraw-on-demand by clients.
|
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
|
// 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.
|
// only the GAM should be sending TextViews to the graphics-server, and a different coding scheme is used for that link.
|
||||||
operation: TextOp,
|
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 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
|
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
|
// this field specifies the beginning and end of a "selected" region of text
|
||||||
pub selected: Option<[u32; 2]>,
|
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>,
|
pub text: xous::String::<3072>,
|
||||||
}
|
}
|
||||||
impl TextView {
|
impl TextView {
|
||||||
|
|
|
||||||
|
|
@ -7,10 +7,12 @@ description = "Program to test various aspects of the kernel"
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
xous = { path = "../../xous-rs" }
|
xous = { path = "../../xous-rs" }
|
||||||
|
log-server = { path = "../log-server" }
|
||||||
|
ticktimer-server = { path = "../ticktimer-server" }
|
||||||
|
log = "0.4"
|
||||||
|
|
||||||
[target.'cfg(not(any(windows,unix)))'.dependencies]
|
[target.'cfg(not(any(windows,unix)))'.dependencies]
|
||||||
utralib = { path = "../../utralib"}
|
utralib = { path = "../../utralib"}
|
||||||
|
|
||||||
[features]
|
[features]
|
||||||
logging = [] # adding this allocates the UART for logging of Xous
|
default = []
|
||||||
default = ["logging"]
|
|
||||||
|
|
|
||||||
|
|
@ -1,336 +1,53 @@
|
||||||
#![cfg_attr(target_os = "none", no_std)]
|
#![cfg_attr(target_os = "none", no_std)]
|
||||||
#![cfg_attr(target_os = "none", no_main)]
|
#![cfg_attr(target_os = "none", no_main)]
|
||||||
|
|
||||||
#[cfg(baremetal)]
|
fn sleep_loop(sleep_ms: usize) {
|
||||||
#[macro_use]
|
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
|
||||||
mod debug;
|
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;
|
let mut loop_count = 0;
|
||||||
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;
|
|
||||||
loop {
|
loop {
|
||||||
if counter.trailing_zeros() >= 12 {
|
// log::info!(
|
||||||
writeln!(output, "LOG: Counter tick: {}", counter).unwrap();
|
// "TEST THREAD {}: {}ms Number of times slept: {}",
|
||||||
}
|
// tid,
|
||||||
counter += 1;
|
// sleep_ms,
|
||||||
// writeln!(output, "LOG: Waiting for an event...").unwrap();
|
// loop_count
|
||||||
let mut envelope =
|
// );
|
||||||
xous::syscall::receive_message(server_addr).expect("couldn't get address");
|
let start_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
|
||||||
let sender = envelope.sender;
|
ticktimer_server::sleep_ms(ticktimer_conn, sleep_ms).unwrap();
|
||||||
// writeln!(output, "LOG: Got message envelope: {:?}", envelope).unwrap();
|
let end_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
|
||||||
match &mut envelope.body {
|
log::info!(
|
||||||
xous::Message::Scalar(msg) => handle_scalar(&mut output, sender, msg, envelope.sender.pid().unwrap()),
|
"TEST THREAD {}: target {}ms, {} loops: Sleep finished (uptime: {}, took {} ms)",
|
||||||
xous::Message::BlockingScalar(msg) => {
|
tid,
|
||||||
writeln!(
|
sleep_ms,
|
||||||
output,
|
loop_count,
|
||||||
"LOG: BlockingScalar message from {}: {:?}",
|
end_time,
|
||||||
envelope.sender, msg
|
end_time - start_time,
|
||||||
)
|
);
|
||||||
.unwrap();
|
loop_count += 1;
|
||||||
}
|
|
||||||
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;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[xous::xous_main]
|
#[xous::xous_main]
|
||||||
fn test_main() -> ! {
|
fn test_main() -> ! {
|
||||||
let mut output = implementation::init();
|
log_server::init_wait().unwrap();
|
||||||
let writer = output.get_writer();
|
xous::create_thread_simple(sleep_loop, 10).unwrap();
|
||||||
println!("LOG: my PID is {}", xous::process::id());
|
xous::create_thread_simple(sleep_loop, 5).unwrap();
|
||||||
println!("LOG: Creating the reader thread");
|
xous::create_thread_simple(sleep_loop, 2).unwrap();
|
||||||
xous::create_thread_simple(reader_thread, writer).unwrap();
|
|
||||||
xous::create_thread_simple(writer_thread, 0usize).unwrap();
|
// let mut ms_count = 1;
|
||||||
println!("LOG: Running the output");
|
loop {
|
||||||
output.run();
|
xous::wait_event();
|
||||||
loop {}
|
// 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) {
|
if CB_RUN.load(Ordering::Relaxed) {
|
||||||
|
|
||||||
CB_RUN.store(false, 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
|
// just send a bogus message
|
||||||
xous::send_message(callback_conn, Message::Scalar(ScalarMessage{
|
xous::send_message(callback_conn, Message::Scalar(ScalarMessage{
|
||||||
id: 0xdeadbeef, arg1: 0, arg2: 0, arg3: 0, arg4: 0,
|
id: 0xdeadbeef, arg1: 0, arg2: 0, arg3: 0, arg4: 0,
|
||||||
|
|
@ -38,7 +38,7 @@ impl CallBack {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> ShellCmdApi<'a> for 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> {
|
fn process(&mut self, _args: String::<1024>, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
|
||||||
use core::fmt::Write;
|
use core::fmt::Write;
|
||||||
|
|
|
||||||
|
|
@ -1,23 +1,24 @@
|
||||||
[package]
|
[package]
|
||||||
|
authors = ["bunnie <bunnie@kosagi.com>"]
|
||||||
|
description = "Provide high-resolution, non-rollover system time"
|
||||||
|
edition = "2018"
|
||||||
name = "ticktimer-server"
|
name = "ticktimer-server"
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
authors = ["bunnie <bunnie@kosagi.com>"]
|
|
||||||
edition = "2018"
|
|
||||||
description = "Provide high-resolution, non-rollover system time"
|
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
xous = { path = "../../xous-rs" }
|
|
||||||
heapless = "0.5"
|
heapless = "0.5"
|
||||||
log-server = { path = "../log-server" }
|
|
||||||
log = "0.4"
|
log = "0.4"
|
||||||
|
log-server = {path = "../log-server"}
|
||||||
|
xous = {path = "../../xous-rs"}
|
||||||
|
|
||||||
[target.'cfg(not(any(windows,unix)))'.dependencies]
|
[target.'cfg(not(any(windows,unix)))'.dependencies]
|
||||||
utralib = { path = "../../utralib"}
|
utralib = {path = "../../utralib"}
|
||||||
|
|
||||||
[target.'cfg(any(windows,unix))'.dependencies]
|
[target.'cfg(any(windows,unix))'.dependencies]
|
||||||
|
|
||||||
[features]
|
[features]
|
||||||
debugprint = []
|
debug-print = []
|
||||||
disablewatchdog = []
|
watchdog = []
|
||||||
# generally you want to disable watchdog if you're doing development.
|
# 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};
|
use xous::{Message, ScalarMessage};
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct TimerToken {
|
||||||
|
token: u64, // this field is 48 bits wide, random number
|
||||||
|
}
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum Opcode {
|
pub enum Opcode {
|
||||||
/// Reset the timer
|
/// Reset the timer
|
||||||
|
|
@ -13,6 +18,24 @@ pub enum Opcode {
|
||||||
|
|
||||||
/// Recalculate the sleep time
|
/// Recalculate the sleep time
|
||||||
RecalculateSleep,
|
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 {
|
impl<'a> core::convert::TryFrom<&'a Message> for Opcode {
|
||||||
|
|
|
||||||
|
|
@ -6,32 +6,50 @@ use api::Opcode;
|
||||||
|
|
||||||
mod os_timer;
|
mod os_timer;
|
||||||
|
|
||||||
use core::convert::TryFrom;
|
|
||||||
|
|
||||||
use heapless::binary_heap::{BinaryHeap, Min};
|
use heapless::binary_heap::{BinaryHeap, Min};
|
||||||
use heapless::consts::*;
|
use heapless::consts::*;
|
||||||
|
|
||||||
|
use core::convert::TryFrom;
|
||||||
|
|
||||||
use log::{error, info};
|
use log::{error, info};
|
||||||
|
|
||||||
#[derive(Eq, Debug)]
|
#[derive(Eq)]
|
||||||
pub struct SleepResponse {
|
pub struct SleepRequest {
|
||||||
msec: usize,
|
msec: i64,
|
||||||
sender: xous::MessageSender,
|
sender: xous::MessageSender,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl core::cmp::Ord for SleepResponse {
|
impl core::fmt::Display for SleepRequest {
|
||||||
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
||||||
self.msec.cmp(&other.msec)
|
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> {
|
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
|
||||||
Some(self.cmp(other))
|
Some(self.cmp(other))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl core::cmp::PartialEq for SleepResponse {
|
impl core::cmp::PartialEq for SleepRequest {
|
||||||
fn eq(&self, other: &Self) -> bool {
|
fn eq(&self, other: &Self) -> bool {
|
||||||
self.msec == other.msec && self.sender == other.sender
|
self.msec == other.msec && self.sender == other.sender
|
||||||
}
|
}
|
||||||
|
|
@ -40,14 +58,14 @@ impl core::cmp::PartialEq for SleepResponse {
|
||||||
#[cfg(target_os = "none")]
|
#[cfg(target_os = "none")]
|
||||||
mod implementation {
|
mod implementation {
|
||||||
const TICKS_PER_MS: u64 = 1;
|
const TICKS_PER_MS: u64 = 1;
|
||||||
use super::SleepResponse;
|
use super::SleepRequest;
|
||||||
use utralib::generated::*;
|
use utralib::generated::*;
|
||||||
|
|
||||||
pub struct XousTickTimer {
|
pub struct XousTickTimer {
|
||||||
csr: utralib::CSR<u32>,
|
csr: utralib::CSR<u32>,
|
||||||
|
#[cfg(feature = "watchdog")]
|
||||||
wdt: utralib::CSR<u32>,
|
wdt: utralib::CSR<u32>,
|
||||||
current_response: Option<SleepResponse>,
|
current_response: Option<SleepRequest>,
|
||||||
response_start: u64,
|
|
||||||
connection: xous::CID,
|
connection: xous::CID,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -58,14 +76,16 @@ mod implementation {
|
||||||
// Safe because we're in an interrupt, and this interrupt is only
|
// Safe because we're in an interrupt, and this interrupt is only
|
||||||
// enabled when this value is not None.
|
// enabled when this value is not None.
|
||||||
let response = xtt.current_response.take().unwrap();
|
let response = xtt.current_response.take().unwrap();
|
||||||
|
|
||||||
xous::return_scalar(response.sender, 0).expect("couldn't send response");
|
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.
|
// This is dangerous and may return an error if the queue is full.
|
||||||
xous::try_send_message(xtt.connection, crate::api::Opcode::RecalculateSleep.into())
|
// Which is fine, because the queue is always recalculated any time a message arrives.
|
||||||
.map(|_| ())
|
xous::try_send_message(xtt.connection, crate::api::Opcode::RecalculateSleep.into()).ok();
|
||||||
.unwrap();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl XousTickTimer {
|
impl XousTickTimer {
|
||||||
|
|
@ -88,17 +108,14 @@ mod implementation {
|
||||||
|
|
||||||
let mut xtt = XousTickTimer {
|
let mut xtt = XousTickTimer {
|
||||||
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
|
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
|
||||||
|
#[cfg(feature = "watchdog")]
|
||||||
wdt: CSR::new(wdt.as_mut_ptr() as *mut u32),
|
wdt: CSR::new(wdt.as_mut_ptr() as *mut u32),
|
||||||
current_response: None,
|
current_response: None,
|
||||||
response_start: 0,
|
|
||||||
connection,
|
connection,
|
||||||
};
|
};
|
||||||
|
|
||||||
if cfg!(feature = "disablewatchdog") {
|
#[cfg(feature = "watchdog")]
|
||||||
// do nothing
|
xtt.wdt.wfo(utra::wdt::WATCHDOG_ENABLE, 1);
|
||||||
} else {
|
|
||||||
xtt.wdt.wfo(utra::wdt::WATCHDOG_ENABLE, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
xous::claim_interrupt(
|
xous::claim_interrupt(
|
||||||
utra::ticktimer::TICKTIMER_IRQ,
|
utra::ticktimer::TICKTIMER_IRQ,
|
||||||
|
|
@ -126,39 +143,58 @@ mod implementation {
|
||||||
self.raw_ticktime() / TICKS_PER_MS
|
self.raw_ticktime() / TICKS_PER_MS
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn stop_interrupt(&mut self) -> Option<SleepResponse> {
|
pub fn stop_interrupt(&mut self) -> Option<SleepRequest> {
|
||||||
self.csr.wfo(utra::ticktimer::EV_ENABLE_ALARM, 0); // Disable the timer
|
// Disable the timer
|
||||||
let current_value = self.elapsed_ms();
|
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() {
|
if let Some(sr) = self.current_response.take() {
|
||||||
Some(SleepResponse {
|
#[cfg(feature = "debug-print")]
|
||||||
msec: (current_value - self.response_start) as _,
|
{
|
||||||
sender: sr.sender,
|
log::info!(
|
||||||
})
|
"TickTimer: Stopping currently-running timer sr.msec: {} elapsed_ms: {}",
|
||||||
|
sr.msec,
|
||||||
|
self.elapsed_ms()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
Some(sr)
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn schedule_response(&mut self, milliseconds: usize, sender: xous::MessageSender) {
|
pub fn schedule_response(&mut self, request: SleepRequest) {
|
||||||
self.current_response = Some(SleepResponse {
|
let irq_target = request.msec;
|
||||||
sender,
|
#[cfg(feature = "debug-print")]
|
||||||
msec: milliseconds,
|
|
||||||
});
|
|
||||||
self.response_start = self.elapsed_ms();
|
|
||||||
let irq_target = self.response_start + (milliseconds as u64);
|
|
||||||
log::info!(
|
log::info!(
|
||||||
"setting a response at {} ms (current time: {} ms)",
|
"TickTimer: setting a response at {} ms (current time: {} ms)",
|
||||||
irq_target,
|
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
|
self.csr
|
||||||
.wo(utra::ticktimer::MSLEEP_TARGET1, (irq_target >> 32) as _);
|
.wo(utra::ticktimer::MSLEEP_TARGET1, (irq_target >> 32) as _);
|
||||||
self.csr
|
self.csr
|
||||||
.wo(utra::ticktimer::MSLEEP_TARGET0, irq_target as _);
|
.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) {
|
pub fn reset_wdt(&mut self) {
|
||||||
// disarm the WDT
|
// disarm the WDT
|
||||||
|
|
||||||
|
|
@ -185,18 +221,22 @@ mod implementation {
|
||||||
|
|
||||||
#[cfg(not(target_os = "none"))]
|
#[cfg(not(target_os = "none"))]
|
||||||
mod implementation {
|
mod implementation {
|
||||||
use super::SleepResponse;
|
use super::SleepRequest;
|
||||||
use std::convert::TryInto;
|
use std::convert::TryInto;
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
enum SleepComms {
|
enum SleepComms {
|
||||||
InterruptSleep,
|
InterruptSleep,
|
||||||
StartSleep(xous::MessageSender, u64 /* ms */),
|
StartSleep(
|
||||||
|
xous::MessageSender,
|
||||||
|
i64, /* ms */
|
||||||
|
u64, /* elapsed */
|
||||||
|
),
|
||||||
}
|
}
|
||||||
pub struct XousTickTimer {
|
pub struct XousTickTimer {
|
||||||
start: std::time::Instant,
|
start: std::time::Instant,
|
||||||
sleep_comms: std::sync::mpsc::Sender<SleepComms>,
|
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 {
|
impl XousTickTimer {
|
||||||
|
|
@ -205,9 +245,8 @@ mod implementation {
|
||||||
let (time_remaining_sender, time_remaining_receiver) = std::sync::mpsc::channel();
|
let (time_remaining_sender, time_remaining_receiver) = std::sync::mpsc::channel();
|
||||||
xous::create_thread(move || {
|
xous::create_thread(move || {
|
||||||
let mut timeout = None;
|
let mut timeout = None;
|
||||||
let mut sender = Default::default();
|
let mut current_response: Option<SleepRequest> = None;
|
||||||
loop {
|
loop {
|
||||||
let start_time = std::time::Instant::now();
|
|
||||||
let result = match timeout {
|
let result = match timeout {
|
||||||
None => sleep_receiver
|
None => sleep_receiver
|
||||||
.recv()
|
.recv()
|
||||||
|
|
@ -216,6 +255,9 @@ mod implementation {
|
||||||
};
|
};
|
||||||
match result {
|
match result {
|
||||||
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
|
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");
|
xous::return_scalar(sender, 0).expect("couldn't send response");
|
||||||
|
|
||||||
// This is dangerous and may panic if the queue is full.
|
// This is dangerous and may panic if the queue is full.
|
||||||
|
|
@ -229,19 +271,35 @@ mod implementation {
|
||||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
|
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
Ok(SleepComms::InterruptSleep) => time_remaining_sender
|
Ok(SleepComms::InterruptSleep) => {
|
||||||
.send(if timeout.is_some() {
|
timeout = None;
|
||||||
Some(SleepResponse {
|
time_remaining_sender.send(current_response.take()).unwrap()
|
||||||
sender,
|
}
|
||||||
msec: start_time.elapsed().as_millis() as _,
|
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 {
|
} else {
|
||||||
None
|
#[cfg(feature = "debug-print")]
|
||||||
})
|
log::info!(
|
||||||
.unwrap(),
|
"Clamping duration to 0 (was: {})m returning to {}",
|
||||||
Ok(SleepComms::StartSleep(new_sender, duration)) => {
|
duration,
|
||||||
timeout = Some(std::time::Duration::from_millis(duration));
|
new_sender
|
||||||
sender = 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()
|
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.sleep_comms.send(SleepComms::InterruptSleep).unwrap();
|
||||||
self.time_remaining_receiver.recv().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
|
self.sleep_comms
|
||||||
.send(SleepComms::StartSleep(sender, milliseconds as _))
|
.send(SleepComms::StartSleep(
|
||||||
|
request.sender,
|
||||||
|
request.msec as i64,
|
||||||
|
self.elapsed_ms(),
|
||||||
|
))
|
||||||
.unwrap();
|
.unwrap();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "watchdog")]
|
||||||
pub fn reset_wdt(&self) {
|
pub fn reset_wdt(&self) {
|
||||||
// dummy function, does nothing
|
// dummy function, does nothing
|
||||||
}
|
}
|
||||||
|
|
@ -284,21 +354,44 @@ use implementation::*;
|
||||||
|
|
||||||
fn recalculate_sleep(
|
fn recalculate_sleep(
|
||||||
ticktimer: &mut XousTickTimer,
|
ticktimer: &mut XousTickTimer,
|
||||||
sleep_heap: &mut BinaryHeap<SleepResponse, U32, Min>,
|
sleep_heap: &mut BinaryHeap<SleepRequest, U32, Min>,
|
||||||
new: Option<SleepResponse>,
|
new: Option<SleepRequest>,
|
||||||
) {
|
) {
|
||||||
|
// If there's a sleep request ongoing now, grab it.
|
||||||
if let Some(current) = ticktimer.stop_interrupt() {
|
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")
|
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
|
sleep_heap
|
||||||
.push(response)
|
.push(request)
|
||||||
.expect("couldn't push new sleep to heap");
|
.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() {
|
if let Some(next_response) = sleep_heap.pop() {
|
||||||
info!("scheduling a response at {}", next_response.msec);
|
#[cfg(feature = "debug-print")]
|
||||||
ticktimer.schedule_response(next_response.msec, next_response.sender);
|
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.
|
// Start the OS timer which is responsible for setting up preemption.
|
||||||
os_timer::init();
|
os_timer::init();
|
||||||
|
|
||||||
|
let mut sleep_heap: BinaryHeap<SleepRequest, U32, Min> = BinaryHeap::new();
|
||||||
|
|
||||||
log_server::init_wait().unwrap();
|
log_server::init_wait().unwrap();
|
||||||
info!("TICKTIMER: my PID is {}", xous::process::id());
|
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")
|
let ticktimer_server = xous::create_server_with_address(b"ticktimer-server")
|
||||||
.expect("Couldn't create Ticktimer server");
|
.expect("Couldn't create Ticktimer server");
|
||||||
info!("TICKTIMER: Server started with SID {:?}", 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
|
ticktimer.reset(); // make sure the time starts from zero
|
||||||
|
|
||||||
loop {
|
loop {
|
||||||
|
#[cfg(feature = "watchdog")]
|
||||||
ticktimer.reset_wdt();
|
ticktimer.reset_wdt();
|
||||||
|
|
||||||
//info!("TickTimer: waiting for message");
|
|
||||||
let envelope = xous::receive_message(ticktimer_server).unwrap();
|
let envelope = xous::receive_message(ticktimer_server).unwrap();
|
||||||
//info!("TickTimer: Message: {:?}", envelope);
|
|
||||||
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
|
if let Ok(opcode) = Opcode::try_from(&envelope.body) {
|
||||||
//info!("TickTimer: Opcode: {:?}", opcode);
|
// info!("TickTimer: Opcode: {:?}", opcode);
|
||||||
match opcode {
|
match opcode {
|
||||||
/*Opcode::Reset => {
|
/*Opcode::Reset => {
|
||||||
info!("TickTimer: reset called");
|
info!("TickTimer: reset called");
|
||||||
ticktimer.reset();
|
ticktimer.reset();
|
||||||
}*/
|
}*/
|
||||||
Opcode::ElapsedMs => {
|
Opcode::ElapsedMs => {
|
||||||
let time = ticktimer.elapsed_ms();
|
let time = ticktimer.elapsed_ms() as i64;
|
||||||
//info!("TickTimer: returning time of {:?}", time);
|
|
||||||
xous::return_scalar2(
|
xous::return_scalar2(
|
||||||
envelope.sender,
|
envelope.sender,
|
||||||
(time & 0xFFFF_FFFFu64) as usize,
|
(time & 0xFFFF_FFFFi64) as usize,
|
||||||
((time >> 32) & 0xFFF_FFFFu64) as usize,
|
((time >> 32) & 0xFFF_FFFFi64) as usize,
|
||||||
)
|
)
|
||||||
.expect("TickTimer: couldn't return time request");
|
.expect("TickTimer: couldn't return time request");
|
||||||
//info!("TickTimer: done returning value");
|
|
||||||
}
|
}
|
||||||
Opcode::SleepMs(ms) => recalculate_sleep(
|
Opcode::SleepMs(ms) => {
|
||||||
&mut ticktimer,
|
recalculate_sleep(
|
||||||
&mut sleep_heap,
|
&mut ticktimer,
|
||||||
Some(SleepResponse {
|
&mut sleep_heap,
|
||||||
msec: ms,
|
Some(SleepRequest {
|
||||||
sender: envelope.sender,
|
msec: ms as i64,
|
||||||
}),
|
sender: envelope.sender,
|
||||||
),
|
}),
|
||||||
|
);
|
||||||
|
}
|
||||||
Opcode::RecalculateSleep => {
|
Opcode::RecalculateSleep => {
|
||||||
recalculate_sleep(&mut ticktimer, &mut sleep_heap, None);
|
recalculate_sleep(&mut ticktimer, &mut sleep_heap, None);
|
||||||
//info!("TickTimer: Done recalculating");
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
|
|
|
||||||
|
|
@ -38,7 +38,7 @@ pub fn init() {
|
||||||
))
|
))
|
||||||
.expect("timer: couldn't claim interrupt");
|
.expect("timer: couldn't claim interrupt");
|
||||||
|
|
||||||
let ms = 100; // tick every 100 ms
|
let ms = 10; // tick every 10 ms
|
||||||
en(false);
|
en(false);
|
||||||
load((SYSTEM_CLOCK_FREQUENCY / 1_000) * ms);
|
load((SYSTEM_CLOCK_FREQUENCY / 1_000) * ms);
|
||||||
reload((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_FRONT: &str = "_IME front end_";
|
||||||
pub const SERVER_NAME_IME_PLUGIN_SHELL: &str = "_IME shell plugin_";
|
pub const SERVER_NAME_IME_PLUGIN_SHELL: &str = "_IME shell plugin_";
|
||||||
pub const SERVER_NAME_SHELLCHAT: &str = "_Shell chat application_";
|
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_FCCAGENT: &str = "_Agent for EMC Testing_";
|
||||||
pub const SERVER_NAME_BENCHMARK: &str= "_Benchmark target_";
|
pub const SERVER_NAME_BENCHMARK: &str= "_Benchmark target_";
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
pub fn id() -> u32 {
|
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
|
pid.get() as u32
|
||||||
} else {
|
} else {
|
||||||
0
|
0
|
||||||
|
|
|
||||||
|
|
@ -1,7 +1,7 @@
|
||||||
use crate::{
|
use crate::{
|
||||||
pid_from_usize, CpuID, Error, MemoryAddress, MemoryFlags, MemoryMessage, MemoryRange,
|
pid_from_usize, CpuID, Error, MemoryAddress, MemoryFlags, MemoryMessage, MemoryRange,
|
||||||
MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessArgs, ProcessInit,
|
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;
|
use core::convert::TryInto;
|
||||||
|
|
||||||
|
|
@ -461,8 +461,9 @@ impl SysCall {
|
||||||
0,
|
0,
|
||||||
]
|
]
|
||||||
}
|
}
|
||||||
SysCall::CreateServerId =>
|
SysCall::CreateServerId => {
|
||||||
[SysCallNumber::CreateServerId as usize, 0, 0, 0, 0, 0, 0, 0],
|
[SysCallNumber::CreateServerId as usize, 0, 0, 0, 0, 0, 0, 0]
|
||||||
|
}
|
||||||
SysCall::ReturnToParent(a1, a2) => [
|
SysCall::ReturnToParent(a1, a2) => [
|
||||||
SysCallNumber::ReturnToParent as usize,
|
SysCallNumber::ReturnToParent as usize,
|
||||||
a1.get() as usize,
|
a1.get() as usize,
|
||||||
|
|
@ -678,24 +679,8 @@ impl SysCall {
|
||||||
0,
|
0,
|
||||||
0,
|
0,
|
||||||
],
|
],
|
||||||
SysCall::GetThreadId => [SysCallNumber::GetThreadId as usize,
|
SysCall::GetThreadId => [SysCallNumber::GetThreadId as usize, 0, 0, 0, 0, 0, 0, 0],
|
||||||
0,
|
SysCall::GetProcessId => [SysCallNumber::GetProcessId as usize, 0, 0, 0, 0, 0, 0, 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) => [
|
SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [
|
||||||
SysCallNumber::Invalid as usize,
|
SysCallNumber::Invalid as usize,
|
||||||
*a1,
|
*a1,
|
||||||
|
|
@ -905,7 +890,10 @@ impl SysCall {
|
||||||
pub fn has_memory(&self) -> bool {
|
pub fn has_memory(&self) -> bool {
|
||||||
match self {
|
match self {
|
||||||
SysCall::TrySendMessage(_, msg) | SysCall::SendMessage(_, msg) => {
|
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,
|
SysCall::ReturnMemory(_, _) => true,
|
||||||
_ => false,
|
_ => false,
|
||||||
|
|
@ -963,13 +951,16 @@ impl SysCall {
|
||||||
|
|
||||||
/// Returns `true` if the given syscall may be called from an IRQ context
|
/// Returns `true` if the given syscall may be called from an IRQ context
|
||||||
pub fn can_call_from_interrupt(&self) -> bool {
|
pub fn can_call_from_interrupt(&self) -> bool {
|
||||||
matches!(self, SysCall::TrySendMessage(_, _)
|
matches!(
|
||||||
| SysCall::TryConnect(_)
|
self,
|
||||||
| SysCall::TryReceiveMessage(_)
|
SysCall::TrySendMessage(_, _)
|
||||||
| SysCall::ReturnToParent(_, _)
|
| SysCall::TryConnect(_)
|
||||||
| SysCall::ReturnScalar2(_, _, _)
|
| SysCall::TryReceiveMessage(_)
|
||||||
| SysCall::ReturnScalar1(_, _)
|
| SysCall::ReturnToParent(_, _)
|
||||||
| SysCall::ReturnMemory(_, _))
|
| SysCall::ReturnScalar2(_, _, _)
|
||||||
|
| SysCall::ReturnScalar1(_, _)
|
||||||
|
| SysCall::ReturnMemory(_, _)
|
||||||
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1406,10 +1397,10 @@ pub fn wait_process(joiner: crate::arch::ProcessHandle) -> SysCallResult {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Get the current process ID
|
/// 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| {
|
rsyscall(SysCall::GetProcessId).and_then(|result| {
|
||||||
if let Result::ProcessID(pid) = result {
|
if let Result::ProcessID(pid) = result {
|
||||||
Ok(Result::ProcessID(pid))
|
Ok(pid)
|
||||||
} else {
|
} else {
|
||||||
Err(Error::InternalError)
|
Err(Error::InternalError)
|
||||||
}
|
}
|
||||||
|
|
@ -1417,10 +1408,10 @@ pub fn current_pid() -> SysCallResult {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Get the current thread ID
|
/// Get the current thread ID
|
||||||
pub fn current_tid() -> SysCallResult {
|
pub fn current_tid() -> core::result::Result<TID, Error> {
|
||||||
rsyscall(SysCall::GetProcessId).and_then(|result| {
|
rsyscall(SysCall::GetThreadId).and_then(|result| {
|
||||||
if let Result::ThreadID(tid) = result {
|
if let Result::ThreadID(tid) = result {
|
||||||
Ok(Result::ThreadID(tid))
|
Ok(tid)
|
||||||
} else {
|
} else {
|
||||||
Err(Error::InternalError)
|
Err(Error::InternalError)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -74,7 +74,7 @@ fn try_main() -> Result<(), DynError> {
|
||||||
let task = env::args().nth(1);
|
let task = env::args().nth(1);
|
||||||
match task.as_deref() {
|
match task.as_deref() {
|
||||||
Some("renode-image") => renode_image(false, &hw_pkgs)?,
|
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("renode-image-debug") => renode_image(true, &hw_pkgs)?,
|
||||||
Some("run") => run(false)?,
|
Some("run") => run(false)?,
|
||||||
Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs)?,
|
Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs)?,
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue