use rusty_rtos_core::config::Config;
use rusty_rtos_core::error::{Error, Result};
use rusty_rtos_core::handle::{EventGroupHandle, TaskHandle};
use rusty_rtos_core::hooks::TickHook;
use rusty_rtos_core::isr::Woken;
use rusty_rtos_core::list::ListId;
use rusty_rtos_core::port::Port;
use rusty_rtos_core::trace::{Event, Trace};
use crate::kernel::{Kernel, OwedTrace};
use crate::lists_for;
use crate::queue::Wait::{self, Ready};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct EventGroup {
pub(crate) bits: u32,
}
const CLEAR_EVENTS_ON_EXIT: u64 = 0x0100_0000;
const UNBLOCKED_DUE_TO_BIT_SET: u64 = 0x0200_0000;
const WAIT_FOR_ALL_BITS: u64 = 0x0400_0000;
pub(crate) const EVENT_BITS_CONTROL_BYTES: u64 = 0xff00_0000;
pub const PENDED_SET_BITS: u16 = u16::MAX;
pub const PENDED_CLEAR_BITS: u16 = u16::MAX - 1;
impl<
C: Config,
P: Port,
T: Trace,
H,
const TASKS: usize,
const ITEMS: usize,
const LISTS: usize,
const QUEUES: usize,
const SLOTS: usize,
const BUFFERS: usize,
const BYTES: usize,
const TIMERS: usize,
const GROUPS: usize,
> Kernel<C, P, T, H, TASKS, ITEMS, LISTS, QUEUES, SLOTS, BUFFERS, BYTES, TIMERS, GROUPS>
where
H: TickHook<Self>,
{
pub(crate) fn event_group_list(group: EventGroupHandle) -> ListId {
let base = u8::try_from(lists_for(C::MAX_PRIORITIES, QUEUES, 0)).unwrap_or(u8::MAX);
base.saturating_add(u8::try_from(group.index()).unwrap_or(u8::MAX))
}
const fn wait_condition_met(current: u32, wait_for: u32, all: bool) -> bool {
if all {
current & wait_for == wait_for
} else {
current & wait_for != 0
}
}
pub fn event_group_create(&mut self) -> Result<EventGroupHandle> {
self.account_for_allocation();
let group = self
.groups
.try_insert(EventGroup::default())
.map_err(|_| Error::Full)?;
let list = Self::event_group_list(group);
while let Ok(Some(item)) = self.lists.head(list) {
let _ = self.lists.remove(item);
}
let tick = self.tick;
self.trace.note_exits(self.port.exits());
self.trace.event(tick, Event::EventGroupCreate { group });
Ok(group)
}
pub fn event_group_delete(&mut self, group: EventGroupHandle) -> Result<()> {
self.groups.resolve(group)?;
self.suspend_all();
let list = Self::event_group_list(group);
while let Ok(Some(item)) = self.lists.head(list) {
self.remove_from_unordered_event_list(item, UNBLOCKED_DUE_TO_BIT_SET)?;
}
let _ = self.groups.remove(group);
let _ = self.resume_all();
self.account_for_allocation();
Ok(())
}
pub fn event_group_bits(&mut self, group: EventGroupHandle) -> Result<u32> {
self.event_group_clear_bits(group, 0)
}
pub fn event_group_bits_from_isr(&self, group: EventGroupHandle) -> Result<u32> {
Ok(self.groups.resolve(group)?.bits)
}
pub fn event_group_clear_bits(&mut self, group: EventGroupHandle, bits: u32) -> Result<u32> {
self.enter_critical();
let result = self.groups.resolve_mut(group).map(|g| {
let before = g.bits;
g.bits &= !bits;
before
});
self.exit_critical();
result
}
pub fn event_group_set_bits(&mut self, group: EventGroupHandle, bits: u32) -> Result<u32> {
self.groups.resolve(group)?;
let list = Self::event_group_list(group);
self.suspend_all();
let tick = self.tick;
self.trace.note_exits(self.port.exits());
self.trace
.event(tick, Event::EventGroupSetBits { group, bits });
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits |= bits;
}
let mut to_clear: u32 = 0;
let mut item = self.lists.head(list)?;
while let Some(this) = item {
let next = self.lists.next(this)?;
let value = self.lists.value(this)?;
let control = value & EVENT_BITS_CONTROL_BYTES;
let waited_for = (value & !EVENT_BITS_CONTROL_BYTES) as u32;
let current = self.groups.resolve(group)?.bits;
if Self::wait_condition_met(current, waited_for, control & WAIT_FOR_ALL_BITS != 0) {
if control & CLEAR_EVENTS_ON_EXIT != 0 {
to_clear |= waited_for;
}
self.remove_from_unordered_event_list(
this,
u64::from(current) | UNBLOCKED_DUE_TO_BIT_SET,
)?;
}
item = next;
}
let result = match self.groups.resolve_mut(group) {
Ok(g) => {
g.bits &= !to_clear;
g.bits
}
Err(_) => 0,
};
let _ = self.resume_all();
Ok(result)
}
pub fn event_group_set_bits_from_isr(
&mut self,
group: EventGroupHandle,
bits: u32,
) -> Result<(bool, Woken)> {
self.pend_group_call(PENDED_SET_BITS, group, bits)
}
pub fn event_group_clear_bits_from_isr(
&mut self,
group: EventGroupHandle,
bits: u32,
) -> Result<(bool, Woken)> {
self.pend_group_call(PENDED_CLEAR_BITS, group, bits)
}
fn pend_group_call(
&mut self,
function: u16,
group: EventGroupHandle,
bits: u32,
) -> Result<(bool, Woken)> {
self.timer_pend_function_call_from_isr(function, u64::from(group.index()), u64::from(bits))
}
pub fn event_group_pended_call(
&mut self,
function: u16,
param1: u64,
param2: u64,
) -> Result<()> {
let Some(group) = self.groups.handle_at(param1 as u16) else {
return Err(Error::Gone);
};
let bits = param2 as u32;
match function {
PENDED_SET_BITS => {
self.event_group_set_bits(group, bits)?;
}
PENDED_CLEAR_BITS => {
self.event_group_clear_bits(group, bits)?;
}
_ => {}
}
Ok(())
}
pub fn event_group_wait_bits(
&mut self,
group: EventGroupHandle,
wait_for: u32,
clear_on_exit: bool,
wait_for_all: bool,
ticks: u64,
) -> Result<Wait<u32>> {
let caller = self.current();
if self.take_event_resume(caller) {
let value = self.reset_event_item_value(caller)?;
let bits = self.finish_wait(group, value, wait_for, clear_on_exit, wait_for_all)?;
self.trace_wait_bits_end(
caller,
group,
wait_for,
value & UNBLOCKED_DUE_TO_BIT_SET == 0,
);
return Ok(Ready(bits));
}
self.groups.resolve(group)?;
self.suspend_all();
let current = self.groups.resolve(group)?.bits;
let mut blocked = false;
let mut timed_out = false;
let mut result = current;
if Self::wait_condition_met(current, wait_for, wait_for_all) {
if clear_on_exit {
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits &= !wait_for;
}
}
} else if ticks == 0 {
timed_out = true;
} else {
let mut control = 0;
if clear_on_exit {
control |= CLEAR_EVENTS_ON_EXIT;
}
if wait_for_all {
control |= WAIT_FOR_ALL_BITS;
}
self.place_on_unordered_event_list(
Self::event_group_list(group),
u64::from(wait_for) | control,
ticks,
)?;
result = 0;
let tick = self.tick;
self.trace.note_exits(self.port.exits());
self.trace.event(
tick,
Event::EventGroupWaitBitsBlock {
group,
bits: wait_for,
},
);
blocked = true;
}
let already_yielded = self.resume_all();
if blocked {
if !already_yielded {
self.yield_or_owe(caller);
}
self.set_event_resume(caller);
return Ok(Wait::Blocked);
}
self.trace_wait_bits_end(caller, group, wait_for, timed_out);
Ok(Ready(result))
}
pub fn event_group_sync(
&mut self,
group: EventGroupHandle,
set: u32,
wait_for: u32,
ticks: u64,
) -> Result<Wait<u32>> {
let caller = self.current();
if self.take_event_resume(caller) {
let value = self.reset_event_item_value(caller)?;
return Ok(Ready(self.finish_sync(group, value, wait_for)?));
}
self.groups.resolve(group)?;
self.suspend_all();
let original = self.groups.resolve(group)?.bits;
self.event_group_set_bits(group, set)?;
let mut blocked = false;
let result;
if (original | set) & wait_for == wait_for {
result = original | set;
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits &= !wait_for;
}
} else if ticks == 0 {
result = self.groups.resolve(group)?.bits;
} else {
self.place_on_unordered_event_list(
Self::event_group_list(group),
u64::from(wait_for) | CLEAR_EVENTS_ON_EXIT | WAIT_FOR_ALL_BITS,
ticks,
)?;
result = 0;
blocked = true;
}
let already_yielded = self.resume_all();
if blocked {
if !already_yielded {
self.yield_or_owe(caller);
}
self.set_event_resume(caller);
return Ok(Wait::Blocked);
}
Ok(Ready(result))
}
fn finish_wait(
&mut self,
group: EventGroupHandle,
value: u64,
wait_for: u32,
clear_on_exit: bool,
wait_for_all: bool,
) -> Result<u32> {
if value & UNBLOCKED_DUE_TO_BIT_SET != 0 {
return Ok((value & !EVENT_BITS_CONTROL_BYTES) as u32);
}
self.enter_critical();
let bits = self.groups.resolve(group).map(|g| g.bits);
if let Ok(bits) = bits {
if Self::wait_condition_met(bits, wait_for, wait_for_all) && clear_on_exit {
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits &= !wait_for;
}
}
}
self.exit_critical();
Ok((u64::from(bits?) & !EVENT_BITS_CONTROL_BYTES) as u32)
}
fn finish_sync(&mut self, group: EventGroupHandle, value: u64, wait_for: u32) -> Result<u32> {
if value & UNBLOCKED_DUE_TO_BIT_SET != 0 {
return Ok((value & !EVENT_BITS_CONTROL_BYTES) as u32);
}
self.enter_critical();
let bits = self.groups.resolve(group).map(|g| g.bits);
if let Ok(bits) = bits {
if bits & wait_for == wait_for {
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits &= !wait_for;
}
}
}
self.exit_critical();
Ok((u64::from(bits?) & !EVENT_BITS_CONTROL_BYTES) as u32)
}
fn trace_wait_bits_end(
&mut self,
caller: TaskHandle,
group: EventGroupHandle,
bits: u32,
timed_out: bool,
) {
self.trace_failure_or_owe(
caller,
OwedTrace::EventGroupWaitBitsEnd {
group,
bits,
timed_out,
},
);
}
}