GPUAPI int pass_two (int thread_in_system)
{
if(is_condition_met() && is_deactivate_on() && (thread_in_system==0) )
{ _sys.set_disabled(); }
return _sys.state();
}
GPUAPI bool need_to_log_system ()
{ return (is_log_on() && is_condition_met() ); }
GPUAPI bool need_to_deactivate ()
{ return ( is_deactivate_on() && is_condition_met() ); }
int k_poll(struct k_poll_event *events, int num_events, s32_t timeout)
{
__ASSERT(!_is_in_isr(), "");
__ASSERT(events, "NULL events\n");
__ASSERT(num_events > 0, "zero events\n");
int last_registered = -1, in_use = 0, rc;
unsigned int key;
key = irq_lock();
set_polling_state(_current);
irq_unlock(key);
/*
* We can get by with one poller structure for all events for now:
* if/when we allow multiple threads to poll on the same object, we
* will need one per poll event associated with an object.
*/
struct _poller poller = { .thread = _current };
/* find events whose condition is already fulfilled */
for (int ii = 0; ii < num_events; ii++) {
u32_t state;
key = irq_lock();
if (is_condition_met(&events[ii], &state)) {
set_event_ready(&events[ii], state);
clear_polling_state(_current);
} else if (timeout != K_NO_WAIT && is_polling() && !in_use) {
rc = register_event(&events[ii]);
if (rc == 0) {
events[ii].poller = &poller;
++last_registered;
} else if (rc == -EADDRINUSE) {
/* setting in_use also prevents any further
* registrations by the current thread
*/
in_use = -EADDRINUSE;
events[ii].state = K_POLL_STATE_EADDRINUSE;
clear_polling_state(_current);
} else {
__ASSERT(0, "unexpected return code\n");
}
}
irq_unlock(key);
}
key = irq_lock();
/*
* If we're not polling anymore, it means that at least one event
* condition is met, either when looping through the events here or
* because one of the events registered has had its state changed, or
* that one of the objects we wanted to poll on already had a thread
* polling on it. We can remove all registrations and return either
* success or a -EADDRINUSE error. In the case of a -EADDRINUSE error,
* the events that were available are still flagged as such, and it is
* valid for the caller to consider them available, as if this function
* returned success.
*/
if (!is_polling()) {
clear_event_registrations(events, last_registered, key);
irq_unlock(key);
return in_use;
}
clear_polling_state(_current);
if (timeout == K_NO_WAIT) {
irq_unlock(key);
return -EAGAIN;
}
_wait_q_t wait_q = _WAIT_Q_INIT(&wait_q);
_pend_current_thread(&wait_q, timeout);
int swap_rc = _Swap(key);
/*
* Clear all event registrations. If events happen while we're in this
* loop, and we already had one that triggered, that's OK: they will
* end up in the list of events that are ready; if we timed out, and
* events happen while we're in this loop, that is OK as well since
* we've already know the return code (-EAGAIN), and even if they are
* added to the list of events that occurred, the user has to check the
* return code first, which invalidates the whole list of event states.
*/
key = irq_lock();
clear_event_registrations(events, last_registered, key);
irq_unlock(key);
return swap_rc;
}