static void tstack_thread_isr(struct k_stack *pstack)
{
k_sem_init(&end_sema, 0, 1);
/**TESTPOINT: thread-isr data passing via stack*/
irq_offload(tIsr_entry_push, pstack);
tstack_pop(pstack);
tstack_push(pstack);
irq_offload(tIsr_entry_pop, pstack);
}
static int ipm_dummy_send(struct device *d, int wait, uint32_t id,
const void *data, int size)
{
struct ipm_dummy_driver_data *driver_data;
volatile uint8_t *datareg;
const uint8_t *data8;
int i;
driver_data = d->driver_data;
if (size > ipm_max_data_size_get(d)) {
return -EMSGSIZE;
}
if (driver_data->regs.busy) {
return -EBUSY;
}
data8 = (const uint8_t *)data;
datareg = (volatile uint8_t *)driver_data->regs.data;
for (i = 0; i < size; ++i) {
datareg[i] = data8[i];
}
driver_data->regs.id = id;
driver_data->regs.busy = 1;
irq_offload(ipm_dummy_isr, d);
if (wait) {
while (driver_data->regs.busy) {
/* busy-wait */
}
}
return 0;
}
static void isr_alert(void)
{
handler_executed = 0;
/**TESTPOINT: thread-isr sync via alert*/
irq_offload(tIsr_entry, NULL);
k_sleep(TIMEOUT);
alert_recv();
}
/**
*
* @brief Interrupt preparation fiber
*
* Fiber makes all the test preparations: registers the interrupt handler,
* gets the first timestamp and invokes the software interrupt.
*
* @return N/A
*/
static void fiberInt(void)
{
flagVar = 0;
irq_offload(latencyTestIsr, NULL);
if (flagVar != 1) {
PRINT_FORMAT(" Flag variable has not changed. FAILED");
} else {
timestamp = TIME_STAMP_DELTA_GET(timestamp);
}
}
static int ipm_dummy_set_enabled(struct device *d, int enable)
{
struct ipm_dummy_driver_data *driver_data = d->driver_data;
driver_data->regs.enabled = enable;
if (enable) {
/* In case there are pending messages */
irq_offload(ipm_dummy_isr, d);
}
return 0;
}
static void helper_fiber(int arg1, int arg2)
{
nano_fiber_sem_take(&helper_fiber_sem, TICKS_UNLIMITED);
/* Wake the test fiber */
fiber_fiber_wakeup(test_fiber_id);
nano_fiber_sem_take(&helper_fiber_sem, TICKS_UNLIMITED);
/* Wake the test fiber from an ISR */
irq_offload(irq_offload_isr, (void *)test_fiber_id);
}
static void helper_thread(int arg1, int arg2)
{
k_sem_take(&helper_thread_sem, K_FOREVER);
/* Wake the test fiber */
k_wakeup(test_thread_id);
k_sem_take(&helper_thread_sem, K_FOREVER);
/* Wake the test fiber from an ISR */
irq_offload(irq_offload_isr, (void *)test_thread_id);
}
/*test cases*/
void test_sched_is_preempt_thread(void)
{
k_sem_init(&end_sema, 0, 1);
/*create preempt thread*/
k_tid_t tid = k_thread_spawn(tstack, STACK_SIZE,
tpreempt_ctx, NULL, NULL, NULL,
K_PRIO_PREEMPT(1), 0, 0);
k_sem_take(&end_sema, K_FOREVER);
k_thread_abort(tid);
/*create coop thread*/
tid = k_thread_spawn(tstack, STACK_SIZE,
tcoop_ctx, NULL, NULL, NULL,
K_PRIO_COOP(1), 0, 0);
k_sem_take(&end_sema, K_FOREVER);
k_thread_abort(tid);
/*invoke isr*/
irq_offload(tIsr, NULL);
}
static void _trigger_nano_isr_stack_pop(void)
{
irq_offload(isr_stack_pop, &isrStackInfo);
}
/**
*
* @brief Interrupt preparation fiber
*
* Fiber makes all the test preparations: registers the interrupt handler,
* gets the first timestamp and invokes the software interrupt.
*
* @return N/A
*/
static void fiberInt(void)
{
timestamp = TIME_STAMP_DELTA_GET(0);
irq_offload(latencyTestIsr, NULL);
}
static void isr_handler_trigger(void)
{
irq_offload(isr_handler, NULL);
}
static void tsema_thread_isr(struct k_sem *psem)
{
/**TESTPOINT: thread-isr sync via sema*/
irq_offload(tIsr_entry, psem);
zassert_false(k_sem_take(psem, K_FOREVER), NULL);
}
/**
*
* @brief Interrupt preparation fiber
*
* Fiber makes all the test preparations: registers the interrupt handler,
* gets the first timestamp and invokes the software interrupt.
*
* @return N/A
*/
static void fiberInt(void)
{
irq_offload(latencyTestIsr, NULL);
fiber_yield();
}
static void _trigger_nano_isr_sem_take(void)
{
irq_offload(isr_sem_take, &isrSemInfo);
}
/**
*
* @brief Software interrupt generating thread
*
* Lower priority thread that, when it starts, it waits for a semaphore. When
* it gets it, released by the main thread, sets up the interrupt handler and
* generates the software interrupt
*
* @return 0 on success
*/
void int_thread(void)
{
k_sem_take(&INTSEMA, K_FOREVER);
irq_offload(latency_test_isr, NULL);
k_thread_suspend(k_current_get());
}
static void _trigger_nano_isr_lifo_get(void)
{
irq_offload(isr_lifo_get, &isrLifoInfo);
}
static void _trigger_nano_isr_fifo_put(void)
{
irq_offload(isr_fifo_put, &isrFifoInfo);
}
