Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | /* * Copyright (c) 2018 Intel Corporation * * SPDX-License-Identifier: Apache-2.0 */ #include <ztest.h> #include <kernel.h> #include <cmsis_os2.h> #include <irq_offload.h> #include <kernel_structs.h> #define TIMEOUT_TICKS (10) #define FLAG1 (0x00000020) #define FLAG2 (0x00000004) #define FLAG (FLAG1 | FLAG2) #define ISR_FLAG (0x50) #define STACKSZ CONFIG_CMSIS_V2_THREAD_MAX_STACK_SIZE static void thread1(void *arg) { u32_t flags; /* wait for FLAG1. It should return immediately as it is * already triggered. */ flags = osThreadFlagsWait(FLAG1, osFlagsWaitAny | osFlagsNoClear, 0); zassert_equal(flags & FLAG1, FLAG1, ""); /* Since the flags are not cleared automatically in the previous step, * we should be able to get the same flags upon query below. */ flags = osThreadFlagsGet(); zassert_equal(flags & FLAG1, FLAG1, ""); /* Clear the Flag explicitly */ flags = osThreadFlagsClear(FLAG1); zassert_not_equal(flags, osFlagsErrorParameter, "ThreadFlagsClear failed"); /* wait for FLAG1. It should timeout here as the flag * though triggered, gets cleared in the previous step. */ flags = osThreadFlagsWait(FLAG1, osFlagsWaitAny, TIMEOUT_TICKS); zassert_equal(flags, osFlagsErrorTimeout, "ThreadFlagsWait failed"); } static void thread2(void *arg) { u32_t flags; flags = osThreadFlagsWait(FLAG, osFlagsWaitAll, TIMEOUT_TICKS); zassert_equal(flags & FLAG, FLAG, "osThreadFlagsWait failed unexpectedly"); /* validate by passing invalid parameters */ zassert_equal(osThreadFlagsSet(NULL, 0), osFlagsErrorParameter, "Invalid Thread Flags ID is unexpectedly working!"); zassert_equal(osThreadFlagsSet(osThreadGetId(), 0x80010000), osFlagsErrorParameter, "Thread with MSB set is set unexpectedly"); zassert_equal(osThreadFlagsClear(0x80010000), osFlagsErrorParameter, "Thread with MSB set is cleared unexpectedly"); /* cannot wait for Flag mask with MSB set */ zassert_equal(osThreadFlagsWait(0x80010000, osFlagsWaitAny, 0), osFlagsErrorParameter, "ThreadFlagsWait passed unexpectedly"); } static K_THREAD_STACK_DEFINE(test_stack1, STACKSZ); static osThreadAttr_t thread1_attr = { .name = "Thread1", .stack_mem = &test_stack1, .stack_size = STACKSZ, .priority = osPriorityHigh, }; static K_THREAD_STACK_DEFINE(test_stack2, STACKSZ); static osThreadAttr_t thread2_attr = { .name = "Thread2", .stack_mem = &test_stack2, .stack_size = STACKSZ, .priority = osPriorityHigh, }; void test_thread_flags_no_wait_timeout(void) { osThreadId_t id1; u32_t flags; id1 = osThreadNew(thread1, NULL, &thread1_attr); zassert_true(id1 != NULL, "Failed creating thread1"); flags = osThreadFlagsSet(id1, FLAG1); zassert_equal(flags & FLAG1, FLAG1, ""); /* Let id1 run to do the tests for Thread Flags */ osDelay(TIMEOUT_TICKS); } void test_thread_flags_signalled(void) { osThreadId_t id; u32_t flags; id = osThreadNew(thread2, osThreadGetId(), &thread2_attr); zassert_true(id != NULL, "Failed creating thread2"); flags = osThreadFlagsSet(id, FLAG1); zassert_equal(flags & FLAG1, FLAG1, ""); /* Let id run to do the tests for Thread Flags */ osDelay(TIMEOUT_TICKS / 2); flags = osThreadFlagsSet(id, FLAG2); zassert_equal(flags & FLAG2, FLAG2, ""); /* z_thread has a higher priority over the other threads. * Hence, this thread needs to be put to sleep for thread2 * to become the active thread. */ osDelay(TIMEOUT_TICKS / 2); } /* IRQ offload function handler to set Thread flag */ static void offload_function(void *param) { int flags; /* Make sure we're in IRQ context */ zassert_true(k_is_in_isr(), "Not in IRQ context!"); flags = osThreadFlagsSet((osThreadId_t)param, ISR_FLAG); zassert_equal(flags & ISR_FLAG, ISR_FLAG, "ThreadFlagsSet failed in ISR"); } void test_thread_flags_from_isr(void *thread_id) { u32_t flags; /**TESTPOINT: Offload to IRQ context*/ irq_offload(offload_function, (void *)osThreadGetId()); flags = osThreadFlagsWait(ISR_FLAG, osFlagsWaitAll, TIMEOUT_TICKS); zassert_equal((flags & ISR_FLAG), ISR_FLAG, "unexpected Thread flags value"); } static K_THREAD_STACK_DEFINE(test_stack3, STACKSZ); static osThreadAttr_t thread3_attr = { .name = "Thread3", .stack_mem = &test_stack3, .stack_size = STACKSZ, .priority = osPriorityHigh, }; void test_thread_flags_isr(void) { osThreadId_t id; id = osThreadNew(test_thread_flags_from_isr, osThreadGetId(), &thread3_attr); zassert_true(id != NULL, "Failed creating thread"); osDelay(TIMEOUT_TICKS); } |