Marco Rubio / mbed-rtos

Rtos code cntains bug possible incompatability with I2C

Fork of mbed-rtos by mbed official

rtx/TARGET_CORTEX_M/rt_CMSIS.c@112:53ace74b190c, 2016-05-05 (annotated)

Committer:
mbed_official
Date:
Thu May 05 20:45:13 2016 +0100
Revision:
112:53ace74b190c
Parent:
101:3d9d2b8b8f17
Child:
114:031a41d65add
Synchronized with git revision 860fdd282b0dc3631a6c46b39442d4ab5343e534



Full URL: https://github.com/mbedmicro/mbed/commit/860fdd282b0dc3631a6c46b39442d4ab5343e534/



rtx update to v4.79

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 49:77c8e4604045 1 /*----------------------------------------------------------------------------
mbed_official 112:53ace74b190c 2 * CMSIS-RTOS - RTX
mbed_official 49:77c8e4604045 3 *----------------------------------------------------------------------------
mbed_official 49:77c8e4604045 4 * Name: rt_CMSIS.c
mbed_official 49:77c8e4604045 5 * Purpose: CMSIS RTOS API
mbed_official 112:53ace74b190c 6 * Rev.: V4.80
mbed_official 49:77c8e4604045 7 *----------------------------------------------------------------------------
mbed_official 49:77c8e4604045 8 *
mbed_official 112:53ace74b190c 9 * Copyright (c) 1999-2009 KEIL, 2009-2015 ARM Germany GmbH
mbed_official 49:77c8e4604045 10 * All rights reserved.
mbed_official 49:77c8e4604045 11 * Redistribution and use in source and binary forms, with or without
mbed_official 49:77c8e4604045 12 * modification, are permitted provided that the following conditions are met:
mbed_official 49:77c8e4604045 13 * - Redistributions of source code must retain the above copyright
mbed_official 49:77c8e4604045 14 * notice, this list of conditions and the following disclaimer.
mbed_official 49:77c8e4604045 15 * - Redistributions in binary form must reproduce the above copyright
mbed_official 49:77c8e4604045 16 * notice, this list of conditions and the following disclaimer in the
mbed_official 49:77c8e4604045 17 * documentation and/or other materials provided with the distribution.
mbed_official 49:77c8e4604045 18 * - Neither the name of ARM nor the names of its contributors may be used
mbed_official 49:77c8e4604045 19 * to endorse or promote products derived from this software without
mbed_official 49:77c8e4604045 20 * specific prior written permission.
mbed_official 49:77c8e4604045 21 *
mbed_official 49:77c8e4604045 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 49:77c8e4604045 23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 49:77c8e4604045 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
mbed_official 49:77c8e4604045 25 * ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
mbed_official 49:77c8e4604045 26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
mbed_official 49:77c8e4604045 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
mbed_official 49:77c8e4604045 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
mbed_official 49:77c8e4604045 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
mbed_official 49:77c8e4604045 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
mbed_official 49:77c8e4604045 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
mbed_official 49:77c8e4604045 32 * POSSIBILITY OF SUCH DAMAGE.
mbed_official 49:77c8e4604045 33 *---------------------------------------------------------------------------*/
mbed_official 49:77c8e4604045 34
mbed_official 49:77c8e4604045 35 #define __CMSIS_GENERIC
mbed_official 49:77c8e4604045 36
mbed_official 49:77c8e4604045 37 #if defined (__CORTEX_M4) || defined (__CORTEX_M4F)
mbed_official 49:77c8e4604045 38 #include "core_cm4.h"
mbed_official 101:3d9d2b8b8f17 39 #elif defined (__CORTEX_M7) || defined (__CORTEX_M7F)
mbed_official 101:3d9d2b8b8f17 40 #include "core_cm7.h"
mbed_official 49:77c8e4604045 41 #elif defined (__CORTEX_M3)
mbed_official 49:77c8e4604045 42 #include "core_cm3.h"
mbed_official 49:77c8e4604045 43 #elif defined (__CORTEX_M0)
mbed_official 49:77c8e4604045 44 #include "core_cm0.h"
mbed_official 49:77c8e4604045 45 #elif defined (__CORTEX_M0PLUS)
mbed_official 49:77c8e4604045 46 #include "core_cm0plus.h"
mbed_official 49:77c8e4604045 47 #else
mbed_official 49:77c8e4604045 48 #error "Missing __CORTEX_Mx definition"
mbed_official 49:77c8e4604045 49 #endif
mbed_official 49:77c8e4604045 50
mbed_official 49:77c8e4604045 51 #include "rt_TypeDef.h"
mbed_official 112:53ace74b190c 52 #include "RTX_Config.h"
mbed_official 49:77c8e4604045 53 #include "rt_System.h"
mbed_official 49:77c8e4604045 54 #include "rt_Task.h"
mbed_official 49:77c8e4604045 55 #include "rt_Event.h"
mbed_official 49:77c8e4604045 56 #include "rt_List.h"
mbed_official 49:77c8e4604045 57 #include "rt_Time.h"
mbed_official 49:77c8e4604045 58 #include "rt_Mutex.h"
mbed_official 49:77c8e4604045 59 #include "rt_Semaphore.h"
mbed_official 49:77c8e4604045 60 #include "rt_Mailbox.h"
mbed_official 49:77c8e4604045 61 #include "rt_MemBox.h"
mbed_official 112:53ace74b190c 62 #include "rt_Memory.h"
mbed_official 49:77c8e4604045 63 #include "rt_HAL_CM.h"
mbed_official 49:77c8e4604045 64
mbed_official 49:77c8e4604045 65 #define os_thread_cb OS_TCB
mbed_official 49:77c8e4604045 66
mbed_official 49:77c8e4604045 67 #include "cmsis_os.h"
mbed_official 49:77c8e4604045 68
mbed_official 49:77c8e4604045 69 #if (osFeature_Signals != 16)
mbed_official 49:77c8e4604045 70 #error Invalid "osFeature_Signals" value!
mbed_official 49:77c8e4604045 71 #endif
mbed_official 49:77c8e4604045 72 #if (osFeature_Semaphore > 65535)
mbed_official 49:77c8e4604045 73 #error Invalid "osFeature_Semaphore" value!
mbed_official 49:77c8e4604045 74 #endif
mbed_official 49:77c8e4604045 75 #if (osFeature_Wait != 0)
mbed_official 49:77c8e4604045 76 #error osWait not supported!
mbed_official 49:77c8e4604045 77 #endif
mbed_official 49:77c8e4604045 78
mbed_official 49:77c8e4604045 79
mbed_official 49:77c8e4604045 80 // ==== Enumeration, structures, defines ====
mbed_official 49:77c8e4604045 81
mbed_official 49:77c8e4604045 82 // Service Calls defines
mbed_official 49:77c8e4604045 83
mbed_official 49:77c8e4604045 84 #if defined (__CC_ARM) /* ARM Compiler */
mbed_official 49:77c8e4604045 85
mbed_official 49:77c8e4604045 86 #define __NO_RETURN __declspec(noreturn)
mbed_official 49:77c8e4604045 87
mbed_official 49:77c8e4604045 88 #define osEvent_type osEvent
mbed_official 49:77c8e4604045 89 #define osEvent_ret_status ret
mbed_official 49:77c8e4604045 90 #define osEvent_ret_value ret
mbed_official 49:77c8e4604045 91 #define osEvent_ret_msg ret
mbed_official 49:77c8e4604045 92 #define osEvent_ret_mail ret
mbed_official 49:77c8e4604045 93
mbed_official 49:77c8e4604045 94 #define osCallback_type osCallback
mbed_official 49:77c8e4604045 95 #define osCallback_ret ret
mbed_official 49:77c8e4604045 96
mbed_official 49:77c8e4604045 97 #define SVC_0_1(f,t,...) \
mbed_official 49:77c8e4604045 98 __svc_indirect(0) t _##f (t(*)()); \
mbed_official 49:77c8e4604045 99 t f (void); \
mbed_official 49:77c8e4604045 100 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 101 static __inline t __##f (void) { \
mbed_official 49:77c8e4604045 102 return _##f(f); \
mbed_official 49:77c8e4604045 103 }
mbed_official 49:77c8e4604045 104
mbed_official 112:53ace74b190c 105 #define SVC_1_0(f,t,t1,...) \
mbed_official 112:53ace74b190c 106 __svc_indirect(0) t _##f (t(*)(t1),t1); \
mbed_official 112:53ace74b190c 107 t f (t1 a1); \
mbed_official 112:53ace74b190c 108 __attribute__((always_inline)) \
mbed_official 112:53ace74b190c 109 static __inline t __##f (t1 a1) { \
mbed_official 112:53ace74b190c 110 _##f(f,a1); \
mbed_official 112:53ace74b190c 111 }
mbed_official 112:53ace74b190c 112
mbed_official 49:77c8e4604045 113 #define SVC_1_1(f,t,t1,...) \
mbed_official 49:77c8e4604045 114 __svc_indirect(0) t _##f (t(*)(t1),t1); \
mbed_official 49:77c8e4604045 115 t f (t1 a1); \
mbed_official 49:77c8e4604045 116 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 117 static __inline t __##f (t1 a1) { \
mbed_official 49:77c8e4604045 118 return _##f(f,a1); \
mbed_official 49:77c8e4604045 119 }
mbed_official 49:77c8e4604045 120
mbed_official 49:77c8e4604045 121 #define SVC_2_1(f,t,t1,t2,...) \
mbed_official 49:77c8e4604045 122 __svc_indirect(0) t _##f (t(*)(t1,t2),t1,t2); \
mbed_official 49:77c8e4604045 123 t f (t1 a1, t2 a2); \
mbed_official 49:77c8e4604045 124 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 125 static __inline t __##f (t1 a1, t2 a2) { \
mbed_official 49:77c8e4604045 126 return _##f(f,a1,a2); \
mbed_official 49:77c8e4604045 127 }
mbed_official 49:77c8e4604045 128
mbed_official 49:77c8e4604045 129 #define SVC_3_1(f,t,t1,t2,t3,...) \
mbed_official 49:77c8e4604045 130 __svc_indirect(0) t _##f (t(*)(t1,t2,t3),t1,t2,t3); \
mbed_official 49:77c8e4604045 131 t f (t1 a1, t2 a2, t3 a3); \
mbed_official 49:77c8e4604045 132 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 133 static __inline t __##f (t1 a1, t2 a2, t3 a3) { \
mbed_official 49:77c8e4604045 134 return _##f(f,a1,a2,a3); \
mbed_official 49:77c8e4604045 135 }
mbed_official 49:77c8e4604045 136
mbed_official 49:77c8e4604045 137 #define SVC_4_1(f,t,t1,t2,t3,t4,...) \
mbed_official 49:77c8e4604045 138 __svc_indirect(0) t _##f (t(*)(t1,t2,t3,t4),t1,t2,t3,t4); \
mbed_official 49:77c8e4604045 139 t f (t1 a1, t2 a2, t3 a3, t4 a4); \
mbed_official 49:77c8e4604045 140 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 141 static __inline t __##f (t1 a1, t2 a2, t3 a3, t4 a4) { \
mbed_official 49:77c8e4604045 142 return _##f(f,a1,a2,a3,a4); \
mbed_official 49:77c8e4604045 143 }
mbed_official 49:77c8e4604045 144
mbed_official 112:53ace74b190c 145 #define SVC_1_2 SVC_1_1
mbed_official 112:53ace74b190c 146 #define SVC_1_3 SVC_1_1
mbed_official 112:53ace74b190c 147 #define SVC_2_3 SVC_2_1
mbed_official 49:77c8e4604045 148
mbed_official 49:77c8e4604045 149 #elif defined (__GNUC__) /* GNU Compiler */
mbed_official 49:77c8e4604045 150
mbed_official 49:77c8e4604045 151 #define __NO_RETURN __attribute__((noreturn))
mbed_official 49:77c8e4604045 152
mbed_official 49:77c8e4604045 153 typedef uint32_t __attribute__((vector_size(8))) ret64;
mbed_official 49:77c8e4604045 154 typedef uint32_t __attribute__((vector_size(16))) ret128;
mbed_official 49:77c8e4604045 155
mbed_official 49:77c8e4604045 156 #define RET_pointer __r0
mbed_official 49:77c8e4604045 157 #define RET_int32_t __r0
mbed_official 112:53ace74b190c 158 #define RET_uint32_t __r0
mbed_official 49:77c8e4604045 159 #define RET_osStatus __r0
mbed_official 49:77c8e4604045 160 #define RET_osPriority __r0
mbed_official 49:77c8e4604045 161 #define RET_osEvent {(osStatus)__r0, {(uint32_t)__r1}, {(void *)__r2}}
mbed_official 49:77c8e4604045 162 #define RET_osCallback {(void *)__r0, (void *)__r1}
mbed_official 49:77c8e4604045 163
mbed_official 112:53ace74b190c 164 #define osEvent_type __attribute__((pcs("aapcs"))) ret128
mbed_official 49:77c8e4604045 165 #define osEvent_ret_status (ret128){ret.status}
mbed_official 49:77c8e4604045 166 #define osEvent_ret_value (ret128){ret.status, ret.value.v}
mbed_official 49:77c8e4604045 167 #define osEvent_ret_msg (ret128){ret.status, ret.value.v, (uint32_t)ret.def.message_id}
mbed_official 49:77c8e4604045 168 #define osEvent_ret_mail (ret128){ret.status, ret.value.v, (uint32_t)ret.def.mail_id}
mbed_official 49:77c8e4604045 169
mbed_official 112:53ace74b190c 170 #define osCallback_type __attribute__((pcs("aapcs"))) ret64
mbed_official 49:77c8e4604045 171 #define osCallback_ret (ret64) {(uint32_t)ret.fp, (uint32_t)ret.arg}
mbed_official 49:77c8e4604045 172
mbed_official 49:77c8e4604045 173 #define SVC_ArgN(n) \
mbed_official 49:77c8e4604045 174 register int __r##n __asm("r"#n);
mbed_official 49:77c8e4604045 175
mbed_official 49:77c8e4604045 176 #define SVC_ArgR(n,t,a) \
mbed_official 49:77c8e4604045 177 register t __r##n __asm("r"#n) = a;
mbed_official 49:77c8e4604045 178
mbed_official 49:77c8e4604045 179 #define SVC_Arg0() \
mbed_official 49:77c8e4604045 180 SVC_ArgN(0) \
mbed_official 49:77c8e4604045 181 SVC_ArgN(1) \
mbed_official 49:77c8e4604045 182 SVC_ArgN(2) \
mbed_official 49:77c8e4604045 183 SVC_ArgN(3)
mbed_official 49:77c8e4604045 184
mbed_official 49:77c8e4604045 185 #define SVC_Arg1(t1) \
mbed_official 49:77c8e4604045 186 SVC_ArgR(0,t1,a1) \
mbed_official 49:77c8e4604045 187 SVC_ArgN(1) \
mbed_official 49:77c8e4604045 188 SVC_ArgN(2) \
mbed_official 49:77c8e4604045 189 SVC_ArgN(3)
mbed_official 49:77c8e4604045 190
mbed_official 49:77c8e4604045 191 #define SVC_Arg2(t1,t2) \
mbed_official 49:77c8e4604045 192 SVC_ArgR(0,t1,a1) \
mbed_official 49:77c8e4604045 193 SVC_ArgR(1,t2,a2) \
mbed_official 49:77c8e4604045 194 SVC_ArgN(2) \
mbed_official 49:77c8e4604045 195 SVC_ArgN(3)
mbed_official 49:77c8e4604045 196
mbed_official 49:77c8e4604045 197 #define SVC_Arg3(t1,t2,t3) \
mbed_official 49:77c8e4604045 198 SVC_ArgR(0,t1,a1) \
mbed_official 49:77c8e4604045 199 SVC_ArgR(1,t2,a2) \
mbed_official 49:77c8e4604045 200 SVC_ArgR(2,t3,a3) \
mbed_official 49:77c8e4604045 201 SVC_ArgN(3)
mbed_official 49:77c8e4604045 202
mbed_official 49:77c8e4604045 203 #define SVC_Arg4(t1,t2,t3,t4) \
mbed_official 49:77c8e4604045 204 SVC_ArgR(0,t1,a1) \
mbed_official 49:77c8e4604045 205 SVC_ArgR(1,t2,a2) \
mbed_official 49:77c8e4604045 206 SVC_ArgR(2,t3,a3) \
mbed_official 49:77c8e4604045 207 SVC_ArgR(3,t4,a4)
mbed_official 49:77c8e4604045 208
mbed_official 49:77c8e4604045 209 #if (defined (__CORTEX_M0)) || defined (__CORTEX_M0PLUS)
mbed_official 49:77c8e4604045 210 #define SVC_Call(f) \
mbed_official 112:53ace74b190c 211 __asm volatile \
mbed_official 49:77c8e4604045 212 ( \
mbed_official 49:77c8e4604045 213 "ldr r7,="#f"\n\t" \
mbed_official 49:77c8e4604045 214 "mov r12,r7\n\t" \
mbed_official 49:77c8e4604045 215 "svc 0" \
mbed_official 49:77c8e4604045 216 : "=r" (__r0), "=r" (__r1), "=r" (__r2), "=r" (__r3) \
mbed_official 49:77c8e4604045 217 : "r" (__r0), "r" (__r1), "r" (__r2), "r" (__r3) \
mbed_official 49:77c8e4604045 218 : "r7", "r12", "lr", "cc" \
mbed_official 49:77c8e4604045 219 );
mbed_official 49:77c8e4604045 220 #else
mbed_official 49:77c8e4604045 221 #define SVC_Call(f) \
mbed_official 112:53ace74b190c 222 __asm volatile \
mbed_official 49:77c8e4604045 223 ( \
mbed_official 49:77c8e4604045 224 "ldr r12,="#f"\n\t" \
mbed_official 49:77c8e4604045 225 "svc 0" \
mbed_official 49:77c8e4604045 226 : "=r" (__r0), "=r" (__r1), "=r" (__r2), "=r" (__r3) \
mbed_official 49:77c8e4604045 227 : "r" (__r0), "r" (__r1), "r" (__r2), "r" (__r3) \
mbed_official 49:77c8e4604045 228 : "r12", "lr", "cc" \
mbed_official 49:77c8e4604045 229 );
mbed_official 49:77c8e4604045 230 #endif
mbed_official 49:77c8e4604045 231
mbed_official 49:77c8e4604045 232 #define SVC_0_1(f,t,rv) \
mbed_official 49:77c8e4604045 233 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 234 static inline t __##f (void) { \
mbed_official 49:77c8e4604045 235 SVC_Arg0(); \
mbed_official 49:77c8e4604045 236 SVC_Call(f); \
mbed_official 49:77c8e4604045 237 return (t) rv; \
mbed_official 49:77c8e4604045 238 }
mbed_official 49:77c8e4604045 239
mbed_official 112:53ace74b190c 240 #define SVC_1_0(f,t,t1) \
mbed_official 112:53ace74b190c 241 __attribute__((always_inline)) \
mbed_official 112:53ace74b190c 242 static inline t __##f (t1 a1) { \
mbed_official 112:53ace74b190c 243 SVC_Arg1(t1); \
mbed_official 112:53ace74b190c 244 SVC_Call(f); \
mbed_official 112:53ace74b190c 245 }
mbed_official 112:53ace74b190c 246
mbed_official 49:77c8e4604045 247 #define SVC_1_1(f,t,t1,rv) \
mbed_official 49:77c8e4604045 248 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 249 static inline t __##f (t1 a1) { \
mbed_official 49:77c8e4604045 250 SVC_Arg1(t1); \
mbed_official 49:77c8e4604045 251 SVC_Call(f); \
mbed_official 49:77c8e4604045 252 return (t) rv; \
mbed_official 49:77c8e4604045 253 }
mbed_official 49:77c8e4604045 254
mbed_official 49:77c8e4604045 255 #define SVC_2_1(f,t,t1,t2,rv) \
mbed_official 49:77c8e4604045 256 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 257 static inline t __##f (t1 a1, t2 a2) { \
mbed_official 49:77c8e4604045 258 SVC_Arg2(t1,t2); \
mbed_official 49:77c8e4604045 259 SVC_Call(f); \
mbed_official 49:77c8e4604045 260 return (t) rv; \
mbed_official 49:77c8e4604045 261 }
mbed_official 49:77c8e4604045 262
mbed_official 49:77c8e4604045 263 #define SVC_3_1(f,t,t1,t2,t3,rv) \
mbed_official 49:77c8e4604045 264 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 265 static inline t __##f (t1 a1, t2 a2, t3 a3) { \
mbed_official 49:77c8e4604045 266 SVC_Arg3(t1,t2,t3); \
mbed_official 49:77c8e4604045 267 SVC_Call(f); \
mbed_official 49:77c8e4604045 268 return (t) rv; \
mbed_official 49:77c8e4604045 269 }
mbed_official 49:77c8e4604045 270
mbed_official 49:77c8e4604045 271 #define SVC_4_1(f,t,t1,t2,t3,t4,rv) \
mbed_official 49:77c8e4604045 272 __attribute__((always_inline)) \
mbed_official 49:77c8e4604045 273 static inline t __##f (t1 a1, t2 a2, t3 a3, t4 a4) { \
mbed_official 49:77c8e4604045 274 SVC_Arg4(t1,t2,t3,t4); \
mbed_official 49:77c8e4604045 275 SVC_Call(f); \
mbed_official 49:77c8e4604045 276 return (t) rv; \
mbed_official 49:77c8e4604045 277 }
mbed_official 49:77c8e4604045 278
mbed_official 112:53ace74b190c 279 #define SVC_1_2 SVC_1_1
mbed_official 112:53ace74b190c 280 #define SVC_1_3 SVC_1_1
mbed_official 112:53ace74b190c 281 #define SVC_2_3 SVC_2_1
mbed_official 49:77c8e4604045 282
mbed_official 49:77c8e4604045 283 #elif defined (__ICCARM__) /* IAR Compiler */
mbed_official 49:77c8e4604045 284
mbed_official 49:77c8e4604045 285 #define __NO_RETURN __noreturn
mbed_official 49:77c8e4604045 286
mbed_official 49:77c8e4604045 287 #define osEvent_type osEvent
mbed_official 49:77c8e4604045 288 #define osEvent_ret_status ret
mbed_official 49:77c8e4604045 289 #define osEvent_ret_value ret
mbed_official 49:77c8e4604045 290 #define osEvent_ret_msg ret
mbed_official 49:77c8e4604045 291 #define osEvent_ret_mail ret
mbed_official 49:77c8e4604045 292
mbed_official 53:c35dab33c427 293 #define osCallback_type osCallback
mbed_official 53:c35dab33c427 294 #define osCallback_ret ret
mbed_official 53:c35dab33c427 295
mbed_official 53:c35dab33c427 296 #define RET_osEvent osEvent
mbed_official 53:c35dab33c427 297 #define RET_osCallback osCallback
mbed_official 49:77c8e4604045 298
mbed_official 49:77c8e4604045 299 #define SVC_Setup(f) \
mbed_official 53:c35dab33c427 300 __asm( \
mbed_official 49:77c8e4604045 301 "mov r12,%0\n" \
mbed_official 49:77c8e4604045 302 :: "r"(&f): "r12" \
mbed_official 49:77c8e4604045 303 );
mbed_official 49:77c8e4604045 304
mbed_official 112:53ace74b190c 305 #define SVC_Ret3() \
mbed_official 112:53ace74b190c 306 __asm( \
mbed_official 112:53ace74b190c 307 "ldr r0,[sp,#0]\n" \
mbed_official 112:53ace74b190c 308 "ldr r1,[sp,#4]\n" \
mbed_official 112:53ace74b190c 309 "ldr r2,[sp,#8]\n" \
mbed_official 112:53ace74b190c 310 );
mbed_official 49:77c8e4604045 311
mbed_official 49:77c8e4604045 312 #define SVC_0_1(f,t,...) \
mbed_official 49:77c8e4604045 313 t f (void); \
mbed_official 49:77c8e4604045 314 _Pragma("swi_number=0") __swi t _##f (void); \
mbed_official 49:77c8e4604045 315 static inline t __##f (void) { \
mbed_official 49:77c8e4604045 316 SVC_Setup(f); \
mbed_official 49:77c8e4604045 317 return _##f(); \
mbed_official 49:77c8e4604045 318 }
mbed_official 49:77c8e4604045 319
mbed_official 112:53ace74b190c 320 #define SVC_1_0(f,t,t1,...) \
mbed_official 112:53ace74b190c 321 t f (t1 a1); \
mbed_official 112:53ace74b190c 322 _Pragma("swi_number=0") __swi t _##f (t1 a1); \
mbed_official 112:53ace74b190c 323 static inline t __##f (t1 a1) { \
mbed_official 112:53ace74b190c 324 SVC_Setup(f); \
mbed_official 112:53ace74b190c 325 _##f(a1); \
mbed_official 112:53ace74b190c 326 }
mbed_official 112:53ace74b190c 327
mbed_official 49:77c8e4604045 328 #define SVC_1_1(f,t,t1,...) \
mbed_official 49:77c8e4604045 329 t f (t1 a1); \
mbed_official 49:77c8e4604045 330 _Pragma("swi_number=0") __swi t _##f (t1 a1); \
mbed_official 49:77c8e4604045 331 static inline t __##f (t1 a1) { \
mbed_official 49:77c8e4604045 332 SVC_Setup(f); \
mbed_official 49:77c8e4604045 333 return _##f(a1); \
mbed_official 49:77c8e4604045 334 }
mbed_official 49:77c8e4604045 335
mbed_official 49:77c8e4604045 336 #define SVC_2_1(f,t,t1,t2,...) \
mbed_official 49:77c8e4604045 337 t f (t1 a1, t2 a2); \
mbed_official 49:77c8e4604045 338 _Pragma("swi_number=0") __swi t _##f (t1 a1, t2 a2); \
mbed_official 49:77c8e4604045 339 static inline t __##f (t1 a1, t2 a2) { \
mbed_official 49:77c8e4604045 340 SVC_Setup(f); \
mbed_official 49:77c8e4604045 341 return _##f(a1,a2); \
mbed_official 49:77c8e4604045 342 }
mbed_official 49:77c8e4604045 343
mbed_official 49:77c8e4604045 344 #define SVC_3_1(f,t,t1,t2,t3,...) \
mbed_official 49:77c8e4604045 345 t f (t1 a1, t2 a2, t3 a3); \
mbed_official 49:77c8e4604045 346 _Pragma("swi_number=0") __swi t _##f (t1 a1, t2 a2, t3 a3); \
mbed_official 49:77c8e4604045 347 static inline t __##f (t1 a1, t2 a2, t3 a3) { \
mbed_official 49:77c8e4604045 348 SVC_Setup(f); \
mbed_official 49:77c8e4604045 349 return _##f(a1,a2,a3); \
mbed_official 49:77c8e4604045 350 }
mbed_official 49:77c8e4604045 351
mbed_official 49:77c8e4604045 352 #define SVC_4_1(f,t,t1,t2,t3,t4,...) \
mbed_official 49:77c8e4604045 353 t f (t1 a1, t2 a2, t3 a3, t4 a4); \
mbed_official 49:77c8e4604045 354 _Pragma("swi_number=0") __swi t _##f (t1 a1, t2 a2, t3 a3, t4 a4); \
mbed_official 49:77c8e4604045 355 static inline t __##f (t1 a1, t2 a2, t3 a3, t4 a4) { \
mbed_official 49:77c8e4604045 356 SVC_Setup(f); \
mbed_official 49:77c8e4604045 357 return _##f(a1,a2,a3,a4); \
mbed_official 49:77c8e4604045 358 }
mbed_official 49:77c8e4604045 359
mbed_official 53:c35dab33c427 360 #define SVC_1_2 SVC_1_1
mbed_official 53:c35dab33c427 361 #define SVC_1_3 SVC_1_1
mbed_official 53:c35dab33c427 362 #define SVC_2_3 SVC_2_1
mbed_official 49:77c8e4604045 363
mbed_official 49:77c8e4604045 364 #endif
mbed_official 49:77c8e4604045 365
mbed_official 49:77c8e4604045 366
mbed_official 49:77c8e4604045 367 // Callback structure
mbed_official 49:77c8e4604045 368 typedef struct {
mbed_official 49:77c8e4604045 369 void *fp; // Function pointer
mbed_official 49:77c8e4604045 370 void *arg; // Function argument
mbed_official 49:77c8e4604045 371 } osCallback;
mbed_official 49:77c8e4604045 372
mbed_official 49:77c8e4604045 373
mbed_official 49:77c8e4604045 374 // OS Section definitions
mbed_official 49:77c8e4604045 375 #ifdef OS_SECTIONS_LINK_INFO
mbed_official 49:77c8e4604045 376 extern const uint32_t os_section_id$$Base;
mbed_official 49:77c8e4604045 377 extern const uint32_t os_section_id$$Limit;
mbed_official 49:77c8e4604045 378 #endif
mbed_official 49:77c8e4604045 379
mbed_official 112:53ace74b190c 380 #ifndef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 381 // OS Stack Memory for Threads definitions
mbed_official 112:53ace74b190c 382 extern uint64_t os_stack_mem[];
mbed_official 112:53ace74b190c 383 extern const uint32_t os_stack_sz;
mbed_official 112:53ace74b190c 384 #endif
mbed_official 112:53ace74b190c 385
mbed_official 49:77c8e4604045 386 // OS Timers external resources
mbed_official 112:53ace74b190c 387 extern const osThreadDef_t os_thread_def_osTimerThread;
mbed_official 112:53ace74b190c 388 extern osThreadId osThreadId_osTimerThread;
mbed_official 112:53ace74b190c 389 extern const osMessageQDef_t os_messageQ_def_osTimerMessageQ;
mbed_official 112:53ace74b190c 390 extern osMessageQId osMessageQId_osTimerMessageQ;
mbed_official 49:77c8e4604045 391
mbed_official 49:77c8e4604045 392
mbed_official 49:77c8e4604045 393 // ==== Helper Functions ====
mbed_official 49:77c8e4604045 394
mbed_official 49:77c8e4604045 395 /// Convert timeout in millisec to system ticks
mbed_official 112:53ace74b190c 396 static uint16_t rt_ms2tick (uint32_t millisec) {
mbed_official 49:77c8e4604045 397 uint32_t tick;
mbed_official 49:77c8e4604045 398
mbed_official 112:53ace74b190c 399 if (millisec == 0U) { return 0x0U; } // No timeout
mbed_official 112:53ace74b190c 400 if (millisec == osWaitForever) { return 0xFFFFU; } // Indefinite timeout
mbed_official 112:53ace74b190c 401 if (millisec > 4000000U) { return 0xFFFEU; } // Max ticks supported
mbed_official 49:77c8e4604045 402
mbed_official 112:53ace74b190c 403 tick = ((1000U * millisec) + os_clockrate - 1U) / os_clockrate;
mbed_official 112:53ace74b190c 404 if (tick > 0xFFFEU) { return 0xFFFEU; }
mbed_official 112:53ace74b190c 405
mbed_official 112:53ace74b190c 406 return (uint16_t)tick;
mbed_official 49:77c8e4604045 407 }
mbed_official 49:77c8e4604045 408
mbed_official 49:77c8e4604045 409 /// Convert Thread ID to TCB pointer
mbed_official 112:53ace74b190c 410 P_TCB rt_tid2ptcb (osThreadId thread_id) {
mbed_official 49:77c8e4604045 411 P_TCB ptcb;
mbed_official 49:77c8e4604045 412
mbed_official 112:53ace74b190c 413 if (thread_id == NULL) { return NULL; }
mbed_official 49:77c8e4604045 414
mbed_official 112:53ace74b190c 415 if ((uint32_t)thread_id & 3U) { return NULL; }
mbed_official 49:77c8e4604045 416
mbed_official 49:77c8e4604045 417 #ifdef OS_SECTIONS_LINK_INFO
mbed_official 112:53ace74b190c 418 if ((os_section_id$$Base != 0U) && (os_section_id$$Limit != 0U)) {
mbed_official 112:53ace74b190c 419 if (thread_id < (osThreadId)os_section_id$$Base) { return NULL; }
mbed_official 112:53ace74b190c 420 if (thread_id >= (osThreadId)os_section_id$$Limit) { return NULL; }
mbed_official 49:77c8e4604045 421 }
mbed_official 49:77c8e4604045 422 #endif
mbed_official 49:77c8e4604045 423
mbed_official 49:77c8e4604045 424 ptcb = thread_id;
mbed_official 49:77c8e4604045 425
mbed_official 112:53ace74b190c 426 if (ptcb->cb_type != TCB) { return NULL; }
mbed_official 49:77c8e4604045 427
mbed_official 49:77c8e4604045 428 return ptcb;
mbed_official 49:77c8e4604045 429 }
mbed_official 49:77c8e4604045 430
mbed_official 49:77c8e4604045 431 /// Convert ID pointer to Object pointer
mbed_official 49:77c8e4604045 432 static void *rt_id2obj (void *id) {
mbed_official 49:77c8e4604045 433
mbed_official 112:53ace74b190c 434 if ((uint32_t)id & 3U) { return NULL; }
mbed_official 49:77c8e4604045 435
mbed_official 49:77c8e4604045 436 #ifdef OS_SECTIONS_LINK_INFO
mbed_official 112:53ace74b190c 437 if ((os_section_id$$Base != 0U) && (os_section_id$$Limit != 0U)) {
mbed_official 112:53ace74b190c 438 if (id < (void *)os_section_id$$Base) { return NULL; }
mbed_official 112:53ace74b190c 439 if (id >= (void *)os_section_id$$Limit) { return NULL; }
mbed_official 49:77c8e4604045 440 }
mbed_official 49:77c8e4604045 441 #endif
mbed_official 49:77c8e4604045 442
mbed_official 49:77c8e4604045 443 return id;
mbed_official 49:77c8e4604045 444 }
mbed_official 49:77c8e4604045 445
mbed_official 49:77c8e4604045 446
mbed_official 49:77c8e4604045 447 // ==== Kernel Control ====
mbed_official 49:77c8e4604045 448
mbed_official 49:77c8e4604045 449 uint8_t os_initialized; // Kernel Initialized flag
mbed_official 49:77c8e4604045 450 uint8_t os_running; // Kernel Running flag
mbed_official 49:77c8e4604045 451
mbed_official 49:77c8e4604045 452 // Kernel Control Service Calls declarations
mbed_official 49:77c8e4604045 453 SVC_0_1(svcKernelInitialize, osStatus, RET_osStatus)
mbed_official 49:77c8e4604045 454 SVC_0_1(svcKernelStart, osStatus, RET_osStatus)
mbed_official 49:77c8e4604045 455 SVC_0_1(svcKernelRunning, int32_t, RET_int32_t)
mbed_official 112:53ace74b190c 456 SVC_0_1(svcKernelSysTick, uint32_t, RET_uint32_t)
mbed_official 49:77c8e4604045 457
mbed_official 112:53ace74b190c 458 static void sysThreadError (osStatus status);
mbed_official 112:53ace74b190c 459 osThreadId svcThreadCreate (const osThreadDef_t *thread_def, void *argument);
mbed_official 112:53ace74b190c 460 osMessageQId svcMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id);
mbed_official 49:77c8e4604045 461
mbed_official 49:77c8e4604045 462 // Kernel Control Service Calls
mbed_official 49:77c8e4604045 463
mbed_official 49:77c8e4604045 464 /// Initialize the RTOS Kernel for creating objects
mbed_official 49:77c8e4604045 465 osStatus svcKernelInitialize (void) {
mbed_official 112:53ace74b190c 466 #ifdef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 467 if (!os_initialized) {
mbed_official 112:53ace74b190c 468 rt_sys_init(); // RTX System Initialization
mbed_official 112:53ace74b190c 469 }
mbed_official 112:53ace74b190c 470 #else
mbed_official 112:53ace74b190c 471 uint32_t ret;
mbed_official 112:53ace74b190c 472
mbed_official 112:53ace74b190c 473 if (os_initialized == 0U) {
mbed_official 49:77c8e4604045 474
mbed_official 112:53ace74b190c 475 // Init Thread Stack Memory (must be 8-byte aligned)
mbed_official 112:53ace74b190c 476 if (((uint32_t)os_stack_mem & 7U) != 0U) { return osErrorNoMemory; }
mbed_official 112:53ace74b190c 477 ret = rt_init_mem(os_stack_mem, os_stack_sz);
mbed_official 112:53ace74b190c 478 if (ret != 0U) { return osErrorNoMemory; }
mbed_official 112:53ace74b190c 479
mbed_official 112:53ace74b190c 480 rt_sys_init(); // RTX System Initialization
mbed_official 112:53ace74b190c 481 }
mbed_official 112:53ace74b190c 482 #endif
mbed_official 112:53ace74b190c 483
mbed_official 112:53ace74b190c 484 os_tsk.run->prio = 255U; // Highest priority
mbed_official 112:53ace74b190c 485
mbed_official 112:53ace74b190c 486 if (os_initialized == 0U) {
mbed_official 112:53ace74b190c 487 // Create OS Timers resources (Message Queue & Thread)
mbed_official 112:53ace74b190c 488 osMessageQId_osTimerMessageQ = svcMessageCreate (&os_messageQ_def_osTimerMessageQ, NULL);
mbed_official 112:53ace74b190c 489 osThreadId_osTimerThread = svcThreadCreate(&os_thread_def_osTimerThread, NULL);
mbed_official 112:53ace74b190c 490 }
mbed_official 49:77c8e4604045 491
mbed_official 49:77c8e4604045 492 sysThreadError(osOK);
mbed_official 49:77c8e4604045 493
mbed_official 112:53ace74b190c 494 os_initialized = 1U;
mbed_official 112:53ace74b190c 495 os_running = 0U;
mbed_official 49:77c8e4604045 496
mbed_official 49:77c8e4604045 497 return osOK;
mbed_official 49:77c8e4604045 498 }
mbed_official 49:77c8e4604045 499
mbed_official 49:77c8e4604045 500 /// Start the RTOS Kernel
mbed_official 49:77c8e4604045 501 osStatus svcKernelStart (void) {
mbed_official 49:77c8e4604045 502
mbed_official 112:53ace74b190c 503 if (os_running) { return osOK; }
mbed_official 49:77c8e4604045 504
mbed_official 112:53ace74b190c 505 rt_tsk_prio(0U, os_tsk.run->prio_base); // Restore priority
mbed_official 112:53ace74b190c 506 if (os_tsk.run->task_id == 0xFFU) { // Idle Thread
mbed_official 112:53ace74b190c 507 __set_PSP(os_tsk.run->tsk_stack + (8U*4U)); // Setup PSP
mbed_official 112:53ace74b190c 508 }
mbed_official 112:53ace74b190c 509 if (os_tsk.new_tsk == NULL) { // Force context switch
mbed_official 112:53ace74b190c 510 os_tsk.new_tsk = os_tsk.run;
mbed_official 112:53ace74b190c 511 os_tsk.run = NULL;
mbed_official 112:53ace74b190c 512 }
mbed_official 49:77c8e4604045 513
mbed_official 49:77c8e4604045 514 rt_sys_start();
mbed_official 49:77c8e4604045 515
mbed_official 112:53ace74b190c 516 os_running = 1U;
mbed_official 49:77c8e4604045 517
mbed_official 49:77c8e4604045 518 return osOK;
mbed_official 49:77c8e4604045 519 }
mbed_official 49:77c8e4604045 520
mbed_official 49:77c8e4604045 521 /// Check if the RTOS kernel is already started
mbed_official 112:53ace74b190c 522 int32_t svcKernelRunning (void) {
mbed_official 112:53ace74b190c 523 return (int32_t)os_running;
mbed_official 112:53ace74b190c 524 }
mbed_official 112:53ace74b190c 525
mbed_official 112:53ace74b190c 526 /// Get the RTOS kernel system timer counter
mbed_official 112:53ace74b190c 527 uint32_t svcKernelSysTick (void) {
mbed_official 112:53ace74b190c 528 uint32_t tick, tick0;
mbed_official 112:53ace74b190c 529
mbed_official 112:53ace74b190c 530 tick = os_tick_val();
mbed_official 112:53ace74b190c 531 if (os_tick_ovf()) {
mbed_official 112:53ace74b190c 532 tick0 = os_tick_val();
mbed_official 112:53ace74b190c 533 if (tick0 < tick) { tick = tick0; }
mbed_official 112:53ace74b190c 534 tick += (os_trv + 1U) * (os_time + 1U);
mbed_official 112:53ace74b190c 535 } else {
mbed_official 112:53ace74b190c 536 tick += (os_trv + 1U) * os_time;
mbed_official 112:53ace74b190c 537 }
mbed_official 112:53ace74b190c 538
mbed_official 112:53ace74b190c 539 return tick;
mbed_official 49:77c8e4604045 540 }
mbed_official 49:77c8e4604045 541
mbed_official 49:77c8e4604045 542 // Kernel Control Public API
mbed_official 49:77c8e4604045 543
mbed_official 49:77c8e4604045 544 /// Initialize the RTOS Kernel for creating objects
mbed_official 49:77c8e4604045 545 osStatus osKernelInitialize (void) {
mbed_official 112:53ace74b190c 546 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 547 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 548 }
mbed_official 112:53ace74b190c 549 if ((__get_CONTROL() & 1U) == 0U) { // Privileged mode
mbed_official 49:77c8e4604045 550 return svcKernelInitialize();
mbed_official 49:77c8e4604045 551 } else {
mbed_official 49:77c8e4604045 552 return __svcKernelInitialize();
mbed_official 49:77c8e4604045 553 }
mbed_official 49:77c8e4604045 554 }
mbed_official 49:77c8e4604045 555
mbed_official 49:77c8e4604045 556 /// Start the RTOS Kernel
mbed_official 49:77c8e4604045 557 osStatus osKernelStart (void) {
mbed_official 49:77c8e4604045 558 uint32_t stack[8];
mbed_official 49:77c8e4604045 559
mbed_official 112:53ace74b190c 560 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 561 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 562 }
mbed_official 112:53ace74b190c 563 switch (__get_CONTROL() & 0x03U) {
mbed_official 112:53ace74b190c 564 case 0x00U: // Privileged Thread mode & MSP
mbed_official 49:77c8e4604045 565 __set_PSP((uint32_t)(stack + 8)); // Initial PSP
mbed_official 112:53ace74b190c 566 if (os_flags & 1U) {
mbed_official 112:53ace74b190c 567 __set_CONTROL(0x02U); // Set Privileged Thread mode & PSP
mbed_official 49:77c8e4604045 568 } else {
mbed_official 112:53ace74b190c 569 __set_CONTROL(0x03U); // Set Unprivileged Thread mode & PSP
mbed_official 49:77c8e4604045 570 }
mbed_official 49:77c8e4604045 571 __DSB();
mbed_official 49:77c8e4604045 572 __ISB();
mbed_official 49:77c8e4604045 573 break;
mbed_official 112:53ace74b190c 574 case 0x01U: // Unprivileged Thread mode & MSP
mbed_official 49:77c8e4604045 575 return osErrorOS;
mbed_official 112:53ace74b190c 576 case 0x02U: // Privileged Thread mode & PSP
mbed_official 112:53ace74b190c 577 if ((os_flags & 1U) == 0U) { // Unprivileged Thread mode requested
mbed_official 112:53ace74b190c 578 __set_CONTROL(0x03U); // Set Unprivileged Thread mode & PSP
mbed_official 49:77c8e4604045 579 __DSB();
mbed_official 49:77c8e4604045 580 __ISB();
mbed_official 49:77c8e4604045 581 }
mbed_official 49:77c8e4604045 582 break;
mbed_official 112:53ace74b190c 583 case 0x03U: // Unprivileged Thread mode & PSP
mbed_official 112:53ace74b190c 584 if (os_flags & 1U) { return osErrorOS; } // Privileged Thread mode requested
mbed_official 49:77c8e4604045 585 break;
mbed_official 49:77c8e4604045 586 }
mbed_official 49:77c8e4604045 587 return __svcKernelStart();
mbed_official 49:77c8e4604045 588 }
mbed_official 49:77c8e4604045 589
mbed_official 49:77c8e4604045 590 /// Check if the RTOS kernel is already started
mbed_official 112:53ace74b190c 591 int32_t osKernelRunning (void) {
mbed_official 112:53ace74b190c 592 if ((__get_IPSR() != 0U) || ((__get_CONTROL() & 1U) == 0U)) {
mbed_official 49:77c8e4604045 593 // in ISR or Privileged
mbed_official 112:53ace74b190c 594 return (int32_t)os_running;
mbed_official 49:77c8e4604045 595 } else {
mbed_official 49:77c8e4604045 596 return __svcKernelRunning();
mbed_official 49:77c8e4604045 597 }
mbed_official 49:77c8e4604045 598 }
mbed_official 49:77c8e4604045 599
mbed_official 112:53ace74b190c 600 /// Get the RTOS kernel system timer counter
mbed_official 112:53ace74b190c 601 uint32_t osKernelSysTick (void) {
mbed_official 112:53ace74b190c 602 if (__get_IPSR() != 0U) { return 0U; } // Not allowed in ISR
mbed_official 112:53ace74b190c 603 return __svcKernelSysTick();
mbed_official 112:53ace74b190c 604 }
mbed_official 112:53ace74b190c 605
mbed_official 49:77c8e4604045 606
mbed_official 49:77c8e4604045 607 // ==== Thread Management ====
mbed_official 49:77c8e4604045 608
mbed_official 112:53ace74b190c 609 /// Set Thread Error (for Create functions which return IDs)
mbed_official 112:53ace74b190c 610 static void sysThreadError (osStatus status) {
mbed_official 112:53ace74b190c 611 // To Do
mbed_official 112:53ace74b190c 612 }
mbed_official 112:53ace74b190c 613
mbed_official 49:77c8e4604045 614 __NO_RETURN void osThreadExit (void);
mbed_official 49:77c8e4604045 615
mbed_official 49:77c8e4604045 616 // Thread Service Calls declarations
mbed_official 112:53ace74b190c 617 SVC_2_1(svcThreadCreate, osThreadId, const osThreadDef_t *, void *, RET_pointer)
mbed_official 112:53ace74b190c 618 SVC_0_1(svcThreadGetId, osThreadId, RET_pointer)
mbed_official 112:53ace74b190c 619 SVC_1_1(svcThreadTerminate, osStatus, osThreadId, RET_osStatus)
mbed_official 112:53ace74b190c 620 SVC_0_1(svcThreadYield, osStatus, RET_osStatus)
mbed_official 112:53ace74b190c 621 SVC_2_1(svcThreadSetPriority, osStatus, osThreadId, osPriority, RET_osStatus)
mbed_official 112:53ace74b190c 622 SVC_1_1(svcThreadGetPriority, osPriority, osThreadId, RET_osPriority)
mbed_official 49:77c8e4604045 623
mbed_official 49:77c8e4604045 624 // Thread Service Calls
mbed_official 49:77c8e4604045 625
mbed_official 49:77c8e4604045 626 /// Create a thread and add it to Active Threads and set it to state READY
mbed_official 112:53ace74b190c 627 osThreadId svcThreadCreate (const osThreadDef_t *thread_def, void *argument) {
mbed_official 49:77c8e4604045 628 P_TCB ptcb;
mbed_official 112:53ace74b190c 629 OS_TID tsk;
mbed_official 112:53ace74b190c 630 void *stk;
mbed_official 49:77c8e4604045 631
mbed_official 49:77c8e4604045 632 if ((thread_def == NULL) ||
mbed_official 49:77c8e4604045 633 (thread_def->pthread == NULL) ||
mbed_official 49:77c8e4604045 634 (thread_def->tpriority < osPriorityIdle) ||
mbed_official 112:53ace74b190c 635 (thread_def->tpriority > osPriorityRealtime)) {
mbed_official 112:53ace74b190c 636 sysThreadError(osErrorParameter);
mbed_official 112:53ace74b190c 637 return NULL;
mbed_official 112:53ace74b190c 638 }
mbed_official 112:53ace74b190c 639
mbed_official 112:53ace74b190c 640 #ifdef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 641 if (thread_def->stacksize != 0) { // Custom stack size
mbed_official 112:53ace74b190c 642 stk = (void *)thread_def->stack_pointer;
mbed_official 112:53ace74b190c 643 } else { // Default stack size
mbed_official 112:53ace74b190c 644 stk = NULL;
mbed_official 112:53ace74b190c 645 }
mbed_official 112:53ace74b190c 646 #else
mbed_official 112:53ace74b190c 647 if (thread_def->stacksize != 0) { // Custom stack size
mbed_official 112:53ace74b190c 648 stk = rt_alloc_mem( // Allocate stack
mbed_official 112:53ace74b190c 649 os_stack_mem,
mbed_official 112:53ace74b190c 650 thread_def->stacksize
mbed_official 112:53ace74b190c 651 );
mbed_official 112:53ace74b190c 652 if (stk == NULL) {
mbed_official 112:53ace74b190c 653 sysThreadError(osErrorNoMemory); // Out of memory
mbed_official 112:53ace74b190c 654 return NULL;
mbed_official 112:53ace74b190c 655 }
mbed_official 112:53ace74b190c 656 } else { // Default stack size
mbed_official 112:53ace74b190c 657 stk = NULL;
mbed_official 112:53ace74b190c 658 }
mbed_official 112:53ace74b190c 659 #endif
mbed_official 112:53ace74b190c 660
mbed_official 112:53ace74b190c 661 tsk = rt_tsk_create( // Create task
mbed_official 112:53ace74b190c 662 (FUNCP)thread_def->pthread, // Task function pointer
mbed_official 112:53ace74b190c 663 (uint32_t)
mbed_official 112:53ace74b190c 664 (thread_def->tpriority-osPriorityIdle+1) | // Task priority
mbed_official 112:53ace74b190c 665 (thread_def->stacksize << 8), // Task stack size in bytes
mbed_official 112:53ace74b190c 666 stk, // Pointer to task's stack
mbed_official 112:53ace74b190c 667 argument // Argument to the task
mbed_official 112:53ace74b190c 668 );
mbed_official 112:53ace74b190c 669
mbed_official 112:53ace74b190c 670 if (tsk == 0U) { // Invalid task ID
mbed_official 112:53ace74b190c 671 #ifndef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 672 if (stk != NULL) {
mbed_official 112:53ace74b190c 673 rt_free_mem(os_stack_mem, stk); // Free allocated stack
mbed_official 112:53ace74b190c 674 }
mbed_official 112:53ace74b190c 675 #endif
mbed_official 112:53ace74b190c 676 sysThreadError(osErrorNoMemory); // Create task failed (Out of memory)
mbed_official 49:77c8e4604045 677 return NULL;
mbed_official 49:77c8e4604045 678 }
mbed_official 49:77c8e4604045 679
mbed_official 112:53ace74b190c 680 ptcb = (P_TCB)os_active_TCB[tsk - 1U]; // TCB pointer
mbed_official 49:77c8e4604045 681
mbed_official 49:77c8e4604045 682 *((uint32_t *)ptcb->tsk_stack + 13) = (uint32_t)osThreadExit;
mbed_official 49:77c8e4604045 683
mbed_official 49:77c8e4604045 684 return ptcb;
mbed_official 49:77c8e4604045 685 }
mbed_official 49:77c8e4604045 686
mbed_official 49:77c8e4604045 687 /// Return the thread ID of the current running thread
mbed_official 49:77c8e4604045 688 osThreadId svcThreadGetId (void) {
mbed_official 49:77c8e4604045 689 OS_TID tsk;
mbed_official 49:77c8e4604045 690
mbed_official 49:77c8e4604045 691 tsk = rt_tsk_self();
mbed_official 112:53ace74b190c 692 if (tsk == 0U) { return NULL; }
mbed_official 112:53ace74b190c 693 return (P_TCB)os_active_TCB[tsk - 1U];
mbed_official 49:77c8e4604045 694 }
mbed_official 49:77c8e4604045 695
mbed_official 49:77c8e4604045 696 /// Terminate execution of a thread and remove it from ActiveThreads
mbed_official 49:77c8e4604045 697 osStatus svcThreadTerminate (osThreadId thread_id) {
mbed_official 49:77c8e4604045 698 OS_RESULT res;
mbed_official 49:77c8e4604045 699 P_TCB ptcb;
mbed_official 112:53ace74b190c 700 #ifndef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 701 void *stk;
mbed_official 112:53ace74b190c 702 #endif
mbed_official 49:77c8e4604045 703
mbed_official 49:77c8e4604045 704 ptcb = rt_tid2ptcb(thread_id); // Get TCB pointer
mbed_official 112:53ace74b190c 705 if (ptcb == NULL) {
mbed_official 112:53ace74b190c 706 return osErrorParameter;
mbed_official 112:53ace74b190c 707 }
mbed_official 112:53ace74b190c 708
mbed_official 112:53ace74b190c 709 #ifndef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 710 stk = ptcb->priv_stack ? ptcb->stack : NULL; // Private stack
mbed_official 112:53ace74b190c 711 #endif
mbed_official 49:77c8e4604045 712
mbed_official 49:77c8e4604045 713 res = rt_tsk_delete(ptcb->task_id); // Delete task
mbed_official 49:77c8e4604045 714
mbed_official 112:53ace74b190c 715 if (res == OS_R_NOK) {
mbed_official 112:53ace74b190c 716 return osErrorResource; // Delete task failed
mbed_official 112:53ace74b190c 717 }
mbed_official 112:53ace74b190c 718
mbed_official 112:53ace74b190c 719 #ifndef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 720 if (stk != NULL) {
mbed_official 112:53ace74b190c 721 rt_free_mem(os_stack_mem, stk); // Free private stack
mbed_official 112:53ace74b190c 722 }
mbed_official 112:53ace74b190c 723 #endif
mbed_official 49:77c8e4604045 724
mbed_official 49:77c8e4604045 725 return osOK;
mbed_official 49:77c8e4604045 726 }
mbed_official 49:77c8e4604045 727
mbed_official 49:77c8e4604045 728 /// Pass control to next thread that is in state READY
mbed_official 49:77c8e4604045 729 osStatus svcThreadYield (void) {
mbed_official 49:77c8e4604045 730 rt_tsk_pass(); // Pass control to next task
mbed_official 49:77c8e4604045 731 return osOK;
mbed_official 49:77c8e4604045 732 }
mbed_official 49:77c8e4604045 733
mbed_official 49:77c8e4604045 734 /// Change priority of an active thread
mbed_official 49:77c8e4604045 735 osStatus svcThreadSetPriority (osThreadId thread_id, osPriority priority) {
mbed_official 49:77c8e4604045 736 OS_RESULT res;
mbed_official 49:77c8e4604045 737 P_TCB ptcb;
mbed_official 49:77c8e4604045 738
mbed_official 49:77c8e4604045 739 ptcb = rt_tid2ptcb(thread_id); // Get TCB pointer
mbed_official 112:53ace74b190c 740 if (ptcb == NULL) {
mbed_official 112:53ace74b190c 741 return osErrorParameter;
mbed_official 112:53ace74b190c 742 }
mbed_official 49:77c8e4604045 743
mbed_official 49:77c8e4604045 744 if ((priority < osPriorityIdle) || (priority > osPriorityRealtime)) {
mbed_official 49:77c8e4604045 745 return osErrorValue;
mbed_official 49:77c8e4604045 746 }
mbed_official 49:77c8e4604045 747
mbed_official 49:77c8e4604045 748 res = rt_tsk_prio( // Change task priority
mbed_official 49:77c8e4604045 749 ptcb->task_id, // Task ID
mbed_official 112:53ace74b190c 750 (uint8_t)(priority - osPriorityIdle + 1) // New task priority
mbed_official 49:77c8e4604045 751 );
mbed_official 49:77c8e4604045 752
mbed_official 112:53ace74b190c 753 if (res == OS_R_NOK) {
mbed_official 112:53ace74b190c 754 return osErrorResource; // Change task priority failed
mbed_official 112:53ace74b190c 755 }
mbed_official 49:77c8e4604045 756
mbed_official 49:77c8e4604045 757 return osOK;
mbed_official 49:77c8e4604045 758 }
mbed_official 49:77c8e4604045 759
mbed_official 49:77c8e4604045 760 /// Get current priority of an active thread
mbed_official 49:77c8e4604045 761 osPriority svcThreadGetPriority (osThreadId thread_id) {
mbed_official 49:77c8e4604045 762 P_TCB ptcb;
mbed_official 49:77c8e4604045 763
mbed_official 49:77c8e4604045 764 ptcb = rt_tid2ptcb(thread_id); // Get TCB pointer
mbed_official 112:53ace74b190c 765 if (ptcb == NULL) {
mbed_official 112:53ace74b190c 766 return osPriorityError;
mbed_official 112:53ace74b190c 767 }
mbed_official 49:77c8e4604045 768
mbed_official 112:53ace74b190c 769 return (osPriority)(ptcb->prio - 1 + osPriorityIdle);
mbed_official 49:77c8e4604045 770 }
mbed_official 49:77c8e4604045 771
mbed_official 49:77c8e4604045 772
mbed_official 49:77c8e4604045 773 // Thread Public API
mbed_official 49:77c8e4604045 774
mbed_official 49:77c8e4604045 775 /// Create a thread and add it to Active Threads and set it to state READY
mbed_official 112:53ace74b190c 776 osThreadId osThreadCreate (const osThreadDef_t *thread_def, void *argument) {
mbed_official 112:53ace74b190c 777 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 778 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 779 }
mbed_official 112:53ace74b190c 780 if (((__get_CONTROL() & 1U) == 0U) && (os_running == 0U)) {
mbed_official 49:77c8e4604045 781 // Privileged and not running
mbed_official 49:77c8e4604045 782 return svcThreadCreate(thread_def, argument);
mbed_official 49:77c8e4604045 783 } else {
mbed_official 49:77c8e4604045 784 return __svcThreadCreate(thread_def, argument);
mbed_official 49:77c8e4604045 785 }
mbed_official 49:77c8e4604045 786 }
mbed_official 49:77c8e4604045 787
mbed_official 49:77c8e4604045 788 /// Return the thread ID of the current running thread
mbed_official 49:77c8e4604045 789 osThreadId osThreadGetId (void) {
mbed_official 112:53ace74b190c 790 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 791 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 792 }
mbed_official 49:77c8e4604045 793 return __svcThreadGetId();
mbed_official 49:77c8e4604045 794 }
mbed_official 49:77c8e4604045 795
mbed_official 49:77c8e4604045 796 /// Terminate execution of a thread and remove it from ActiveThreads
mbed_official 49:77c8e4604045 797 osStatus osThreadTerminate (osThreadId thread_id) {
mbed_official 112:53ace74b190c 798 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 799 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 800 }
mbed_official 49:77c8e4604045 801 return __svcThreadTerminate(thread_id);
mbed_official 49:77c8e4604045 802 }
mbed_official 49:77c8e4604045 803
mbed_official 49:77c8e4604045 804 /// Pass control to next thread that is in state READY
mbed_official 49:77c8e4604045 805 osStatus osThreadYield (void) {
mbed_official 112:53ace74b190c 806 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 807 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 808 }
mbed_official 49:77c8e4604045 809 return __svcThreadYield();
mbed_official 49:77c8e4604045 810 }
mbed_official 49:77c8e4604045 811
mbed_official 49:77c8e4604045 812 /// Change priority of an active thread
mbed_official 49:77c8e4604045 813 osStatus osThreadSetPriority (osThreadId thread_id, osPriority priority) {
mbed_official 112:53ace74b190c 814 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 815 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 816 }
mbed_official 49:77c8e4604045 817 return __svcThreadSetPriority(thread_id, priority);
mbed_official 49:77c8e4604045 818 }
mbed_official 49:77c8e4604045 819
mbed_official 49:77c8e4604045 820 /// Get current priority of an active thread
mbed_official 49:77c8e4604045 821 osPriority osThreadGetPriority (osThreadId thread_id) {
mbed_official 112:53ace74b190c 822 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 823 return osPriorityError; // Not allowed in ISR
mbed_official 112:53ace74b190c 824 }
mbed_official 49:77c8e4604045 825 return __svcThreadGetPriority(thread_id);
mbed_official 49:77c8e4604045 826 }
mbed_official 49:77c8e4604045 827
mbed_official 49:77c8e4604045 828 /// INTERNAL - Not Public
mbed_official 49:77c8e4604045 829 /// Auto Terminate Thread on exit (used implicitly when thread exists)
mbed_official 112:53ace74b190c 830 __NO_RETURN void osThreadExit (void) {
mbed_official 112:53ace74b190c 831 __svcThreadTerminate(__svcThreadGetId());
mbed_official 49:77c8e4604045 832 for (;;); // Should never come here
mbed_official 49:77c8e4604045 833 }
mbed_official 49:77c8e4604045 834
mbed_official 112:53ace74b190c 835 #ifdef __MBED_CMSIS_RTOS_CM
mbed_official 112:53ace74b190c 836 /// Get current thread state
mbed_official 112:53ace74b190c 837 uint8_t osThreadGetState (osThreadId thread_id) {
mbed_official 112:53ace74b190c 838 P_TCB ptcb;
mbed_official 112:53ace74b190c 839
mbed_official 112:53ace74b190c 840 if (__get_IPSR() != 0U) return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 841
mbed_official 112:53ace74b190c 842 ptcb = rt_tid2ptcb(thread_id); // Get TCB pointer
mbed_official 112:53ace74b190c 843 if (ptcb == NULL) return osErrorParameter;
mbed_official 112:53ace74b190c 844
mbed_official 112:53ace74b190c 845 return ptcb->state;
mbed_official 112:53ace74b190c 846 }
mbed_official 112:53ace74b190c 847 #endif
mbed_official 49:77c8e4604045 848
mbed_official 49:77c8e4604045 849 // ==== Generic Wait Functions ====
mbed_official 49:77c8e4604045 850
mbed_official 49:77c8e4604045 851 // Generic Wait Service Calls declarations
mbed_official 49:77c8e4604045 852 SVC_1_1(svcDelay, osStatus, uint32_t, RET_osStatus)
mbed_official 49:77c8e4604045 853 #if osFeature_Wait != 0
mbed_official 49:77c8e4604045 854 SVC_1_3(svcWait, os_InRegs osEvent, uint32_t, RET_osEvent)
mbed_official 49:77c8e4604045 855 #endif
mbed_official 49:77c8e4604045 856
mbed_official 49:77c8e4604045 857 // Generic Wait Service Calls
mbed_official 49:77c8e4604045 858
mbed_official 49:77c8e4604045 859 /// Wait for Timeout (Time Delay)
mbed_official 49:77c8e4604045 860 osStatus svcDelay (uint32_t millisec) {
mbed_official 112:53ace74b190c 861 if (millisec == 0U) { return osOK; }
mbed_official 49:77c8e4604045 862 rt_dly_wait(rt_ms2tick(millisec));
mbed_official 49:77c8e4604045 863 return osEventTimeout;
mbed_official 49:77c8e4604045 864 }
mbed_official 49:77c8e4604045 865
mbed_official 49:77c8e4604045 866 /// Wait for Signal, Message, Mail, or Timeout
mbed_official 49:77c8e4604045 867 #if osFeature_Wait != 0
mbed_official 49:77c8e4604045 868 os_InRegs osEvent_type svcWait (uint32_t millisec) {
mbed_official 49:77c8e4604045 869 osEvent ret;
mbed_official 49:77c8e4604045 870
mbed_official 112:53ace74b190c 871 if (millisec == 0U) {
mbed_official 49:77c8e4604045 872 ret.status = osOK;
mbed_official 49:77c8e4604045 873 return osEvent_ret_status;
mbed_official 49:77c8e4604045 874 }
mbed_official 49:77c8e4604045 875
mbed_official 49:77c8e4604045 876 /* To Do: osEventSignal, osEventMessage, osEventMail */
mbed_official 49:77c8e4604045 877 rt_dly_wait(rt_ms2tick(millisec));
mbed_official 49:77c8e4604045 878 ret.status = osEventTimeout;
mbed_official 49:77c8e4604045 879
mbed_official 49:77c8e4604045 880 return osEvent_ret_status;
mbed_official 49:77c8e4604045 881 }
mbed_official 49:77c8e4604045 882 #endif
mbed_official 49:77c8e4604045 883
mbed_official 49:77c8e4604045 884
mbed_official 49:77c8e4604045 885 // Generic Wait API
mbed_official 49:77c8e4604045 886
mbed_official 49:77c8e4604045 887 /// Wait for Timeout (Time Delay)
mbed_official 49:77c8e4604045 888 osStatus osDelay (uint32_t millisec) {
mbed_official 112:53ace74b190c 889 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 890 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 891 }
mbed_official 49:77c8e4604045 892 return __svcDelay(millisec);
mbed_official 49:77c8e4604045 893 }
mbed_official 49:77c8e4604045 894
mbed_official 49:77c8e4604045 895 /// Wait for Signal, Message, Mail, or Timeout
mbed_official 49:77c8e4604045 896 os_InRegs osEvent osWait (uint32_t millisec) {
mbed_official 49:77c8e4604045 897 osEvent ret;
mbed_official 49:77c8e4604045 898
mbed_official 49:77c8e4604045 899 #if osFeature_Wait == 0
mbed_official 49:77c8e4604045 900 ret.status = osErrorOS;
mbed_official 49:77c8e4604045 901 return ret;
mbed_official 49:77c8e4604045 902 #else
mbed_official 112:53ace74b190c 903 if (__get_IPSR() != 0U) { // Not allowed in ISR
mbed_official 49:77c8e4604045 904 ret.status = osErrorISR;
mbed_official 49:77c8e4604045 905 return ret;
mbed_official 49:77c8e4604045 906 }
mbed_official 49:77c8e4604045 907 return __svcWait(millisec);
mbed_official 49:77c8e4604045 908 #endif
mbed_official 49:77c8e4604045 909 }
mbed_official 49:77c8e4604045 910
mbed_official 49:77c8e4604045 911
mbed_official 49:77c8e4604045 912 // ==== Timer Management ====
mbed_official 49:77c8e4604045 913
mbed_official 49:77c8e4604045 914 // Timer definitions
mbed_official 112:53ace74b190c 915 #define osTimerInvalid 0U
mbed_official 112:53ace74b190c 916 #define osTimerStopped 1U
mbed_official 112:53ace74b190c 917 #define osTimerRunning 2U
mbed_official 49:77c8e4604045 918
mbed_official 112:53ace74b190c 919 // Timer structures
mbed_official 49:77c8e4604045 920
mbed_official 49:77c8e4604045 921 typedef struct os_timer_cb_ { // Timer Control Block
mbed_official 49:77c8e4604045 922 struct os_timer_cb_ *next; // Pointer to next active Timer
mbed_official 49:77c8e4604045 923 uint8_t state; // Timer State
mbed_official 49:77c8e4604045 924 uint8_t type; // Timer Type (Periodic/One-shot)
mbed_official 49:77c8e4604045 925 uint16_t reserved; // Reserved
mbed_official 112:53ace74b190c 926 uint32_t tcnt; // Timer Delay Count
mbed_official 112:53ace74b190c 927 uint32_t icnt; // Timer Initial Count
mbed_official 49:77c8e4604045 928 void *arg; // Timer Function Argument
mbed_official 112:53ace74b190c 929 const osTimerDef_t *timer; // Pointer to Timer definition
mbed_official 49:77c8e4604045 930 } os_timer_cb;
mbed_official 49:77c8e4604045 931
mbed_official 49:77c8e4604045 932 // Timer variables
mbed_official 49:77c8e4604045 933 os_timer_cb *os_timer_head; // Pointer to first active Timer
mbed_official 49:77c8e4604045 934
mbed_official 49:77c8e4604045 935
mbed_official 49:77c8e4604045 936 // Timer Helper Functions
mbed_official 49:77c8e4604045 937
mbed_official 49:77c8e4604045 938 // Insert Timer into the list sorted by time
mbed_official 49:77c8e4604045 939 static void rt_timer_insert (os_timer_cb *pt, uint32_t tcnt) {
mbed_official 49:77c8e4604045 940 os_timer_cb *p, *prev;
mbed_official 49:77c8e4604045 941
mbed_official 49:77c8e4604045 942 prev = NULL;
mbed_official 49:77c8e4604045 943 p = os_timer_head;
mbed_official 49:77c8e4604045 944 while (p != NULL) {
mbed_official 112:53ace74b190c 945 if (tcnt < p->tcnt) { break; }
mbed_official 49:77c8e4604045 946 tcnt -= p->tcnt;
mbed_official 49:77c8e4604045 947 prev = p;
mbed_official 49:77c8e4604045 948 p = p->next;
mbed_official 49:77c8e4604045 949 }
mbed_official 49:77c8e4604045 950 pt->next = p;
mbed_official 112:53ace74b190c 951 pt->tcnt = tcnt;
mbed_official 49:77c8e4604045 952 if (p != NULL) {
mbed_official 49:77c8e4604045 953 p->tcnt -= pt->tcnt;
mbed_official 49:77c8e4604045 954 }
mbed_official 49:77c8e4604045 955 if (prev != NULL) {
mbed_official 49:77c8e4604045 956 prev->next = pt;
mbed_official 49:77c8e4604045 957 } else {
mbed_official 49:77c8e4604045 958 os_timer_head = pt;
mbed_official 49:77c8e4604045 959 }
mbed_official 49:77c8e4604045 960 }
mbed_official 49:77c8e4604045 961
mbed_official 49:77c8e4604045 962 // Remove Timer from the list
mbed_official 112:53ace74b190c 963 static int32_t rt_timer_remove (os_timer_cb *pt) {
mbed_official 49:77c8e4604045 964 os_timer_cb *p, *prev;
mbed_official 49:77c8e4604045 965
mbed_official 49:77c8e4604045 966 prev = NULL;
mbed_official 49:77c8e4604045 967 p = os_timer_head;
mbed_official 49:77c8e4604045 968 while (p != NULL) {
mbed_official 112:53ace74b190c 969 if (p == pt) { break; }
mbed_official 49:77c8e4604045 970 prev = p;
mbed_official 49:77c8e4604045 971 p = p->next;
mbed_official 49:77c8e4604045 972 }
mbed_official 112:53ace74b190c 973 if (p == NULL) { return -1; }
mbed_official 49:77c8e4604045 974 if (prev != NULL) {
mbed_official 49:77c8e4604045 975 prev->next = pt->next;
mbed_official 49:77c8e4604045 976 } else {
mbed_official 49:77c8e4604045 977 os_timer_head = pt->next;
mbed_official 49:77c8e4604045 978 }
mbed_official 49:77c8e4604045 979 if (pt->next != NULL) {
mbed_official 49:77c8e4604045 980 pt->next->tcnt += pt->tcnt;
mbed_official 49:77c8e4604045 981 }
mbed_official 49:77c8e4604045 982
mbed_official 49:77c8e4604045 983 return 0;
mbed_official 49:77c8e4604045 984 }
mbed_official 49:77c8e4604045 985
mbed_official 49:77c8e4604045 986
mbed_official 49:77c8e4604045 987 // Timer Service Calls declarations
mbed_official 112:53ace74b190c 988 SVC_3_1(svcTimerCreate, osTimerId, const osTimerDef_t *, os_timer_type, void *, RET_pointer)
mbed_official 112:53ace74b190c 989 SVC_2_1(svcTimerStart, osStatus, osTimerId, uint32_t, RET_osStatus)
mbed_official 112:53ace74b190c 990 SVC_1_1(svcTimerStop, osStatus, osTimerId, RET_osStatus)
mbed_official 112:53ace74b190c 991 SVC_1_1(svcTimerDelete, osStatus, osTimerId, RET_osStatus)
mbed_official 112:53ace74b190c 992 SVC_1_2(svcTimerCall, os_InRegs osCallback, osTimerId, RET_osCallback)
mbed_official 49:77c8e4604045 993
mbed_official 49:77c8e4604045 994 // Timer Management Service Calls
mbed_official 49:77c8e4604045 995
mbed_official 49:77c8e4604045 996 /// Create timer
mbed_official 112:53ace74b190c 997 osTimerId svcTimerCreate (const osTimerDef_t *timer_def, os_timer_type type, void *argument) {
mbed_official 49:77c8e4604045 998 os_timer_cb *pt;
mbed_official 49:77c8e4604045 999
mbed_official 49:77c8e4604045 1000 if ((timer_def == NULL) || (timer_def->ptimer == NULL)) {
mbed_official 49:77c8e4604045 1001 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1002 return NULL;
mbed_official 49:77c8e4604045 1003 }
mbed_official 49:77c8e4604045 1004
mbed_official 49:77c8e4604045 1005 pt = timer_def->timer;
mbed_official 49:77c8e4604045 1006 if (pt == NULL) {
mbed_official 49:77c8e4604045 1007 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1008 return NULL;
mbed_official 49:77c8e4604045 1009 }
mbed_official 49:77c8e4604045 1010
mbed_official 49:77c8e4604045 1011 if ((type != osTimerOnce) && (type != osTimerPeriodic)) {
mbed_official 49:77c8e4604045 1012 sysThreadError(osErrorValue);
mbed_official 49:77c8e4604045 1013 return NULL;
mbed_official 49:77c8e4604045 1014 }
mbed_official 49:77c8e4604045 1015
mbed_official 49:77c8e4604045 1016 if (osThreadId_osTimerThread == NULL) {
mbed_official 49:77c8e4604045 1017 sysThreadError(osErrorResource);
mbed_official 49:77c8e4604045 1018 return NULL;
mbed_official 49:77c8e4604045 1019 }
mbed_official 49:77c8e4604045 1020
mbed_official 49:77c8e4604045 1021 if (pt->state != osTimerInvalid){
mbed_official 49:77c8e4604045 1022 sysThreadError(osErrorResource);
mbed_official 49:77c8e4604045 1023 return NULL;
mbed_official 49:77c8e4604045 1024 }
mbed_official 49:77c8e4604045 1025
mbed_official 112:53ace74b190c 1026 pt->next = NULL;
mbed_official 49:77c8e4604045 1027 pt->state = osTimerStopped;
mbed_official 49:77c8e4604045 1028 pt->type = (uint8_t)type;
mbed_official 49:77c8e4604045 1029 pt->arg = argument;
mbed_official 49:77c8e4604045 1030 pt->timer = timer_def;
mbed_official 49:77c8e4604045 1031
mbed_official 49:77c8e4604045 1032 return (osTimerId)pt;
mbed_official 49:77c8e4604045 1033 }
mbed_official 49:77c8e4604045 1034
mbed_official 49:77c8e4604045 1035 /// Start or restart timer
mbed_official 49:77c8e4604045 1036 osStatus svcTimerStart (osTimerId timer_id, uint32_t millisec) {
mbed_official 49:77c8e4604045 1037 os_timer_cb *pt;
mbed_official 49:77c8e4604045 1038 uint32_t tcnt;
mbed_official 49:77c8e4604045 1039
mbed_official 49:77c8e4604045 1040 pt = rt_id2obj(timer_id);
mbed_official 112:53ace74b190c 1041 if (pt == NULL) {
mbed_official 112:53ace74b190c 1042 return osErrorParameter;
mbed_official 112:53ace74b190c 1043 }
mbed_official 49:77c8e4604045 1044
mbed_official 112:53ace74b190c 1045 if (millisec == 0U) { return osErrorValue; }
mbed_official 112:53ace74b190c 1046
mbed_official 112:53ace74b190c 1047 tcnt = (uint32_t)(((1000U * (uint64_t)millisec) + os_clockrate - 1U) / os_clockrate);
mbed_official 49:77c8e4604045 1048
mbed_official 49:77c8e4604045 1049 switch (pt->state) {
mbed_official 49:77c8e4604045 1050 case osTimerRunning:
mbed_official 49:77c8e4604045 1051 if (rt_timer_remove(pt) != 0) {
mbed_official 49:77c8e4604045 1052 return osErrorResource;
mbed_official 49:77c8e4604045 1053 }
mbed_official 49:77c8e4604045 1054 break;
mbed_official 49:77c8e4604045 1055 case osTimerStopped:
mbed_official 49:77c8e4604045 1056 pt->state = osTimerRunning;
mbed_official 112:53ace74b190c 1057 pt->icnt = tcnt;
mbed_official 49:77c8e4604045 1058 break;
mbed_official 49:77c8e4604045 1059 default:
mbed_official 49:77c8e4604045 1060 return osErrorResource;
mbed_official 49:77c8e4604045 1061 }
mbed_official 112:53ace74b190c 1062
mbed_official 49:77c8e4604045 1063 rt_timer_insert(pt, tcnt);
mbed_official 49:77c8e4604045 1064
mbed_official 49:77c8e4604045 1065 return osOK;
mbed_official 49:77c8e4604045 1066 }
mbed_official 49:77c8e4604045 1067
mbed_official 49:77c8e4604045 1068 /// Stop timer
mbed_official 49:77c8e4604045 1069 osStatus svcTimerStop (osTimerId timer_id) {
mbed_official 49:77c8e4604045 1070 os_timer_cb *pt;
mbed_official 49:77c8e4604045 1071
mbed_official 49:77c8e4604045 1072 pt = rt_id2obj(timer_id);
mbed_official 112:53ace74b190c 1073 if (pt == NULL) {
mbed_official 112:53ace74b190c 1074 return osErrorParameter;
mbed_official 112:53ace74b190c 1075 }
mbed_official 49:77c8e4604045 1076
mbed_official 112:53ace74b190c 1077 if (pt->state != osTimerRunning) { return osErrorResource; }
mbed_official 49:77c8e4604045 1078
mbed_official 49:77c8e4604045 1079 pt->state = osTimerStopped;
mbed_official 49:77c8e4604045 1080
mbed_official 49:77c8e4604045 1081 if (rt_timer_remove(pt) != 0) {
mbed_official 49:77c8e4604045 1082 return osErrorResource;
mbed_official 49:77c8e4604045 1083 }
mbed_official 49:77c8e4604045 1084
mbed_official 49:77c8e4604045 1085 return osOK;
mbed_official 49:77c8e4604045 1086 }
mbed_official 49:77c8e4604045 1087
mbed_official 49:77c8e4604045 1088 /// Delete timer
mbed_official 49:77c8e4604045 1089 osStatus svcTimerDelete (osTimerId timer_id) {
mbed_official 49:77c8e4604045 1090 os_timer_cb *pt;
mbed_official 49:77c8e4604045 1091
mbed_official 49:77c8e4604045 1092 pt = rt_id2obj(timer_id);
mbed_official 112:53ace74b190c 1093 if (pt == NULL) {
mbed_official 112:53ace74b190c 1094 return osErrorParameter;
mbed_official 112:53ace74b190c 1095 }
mbed_official 49:77c8e4604045 1096
mbed_official 49:77c8e4604045 1097 switch (pt->state) {
mbed_official 49:77c8e4604045 1098 case osTimerRunning:
mbed_official 49:77c8e4604045 1099 rt_timer_remove(pt);
mbed_official 49:77c8e4604045 1100 break;
mbed_official 49:77c8e4604045 1101 case osTimerStopped:
mbed_official 49:77c8e4604045 1102 break;
mbed_official 49:77c8e4604045 1103 default:
mbed_official 49:77c8e4604045 1104 return osErrorResource;
mbed_official 49:77c8e4604045 1105 }
mbed_official 49:77c8e4604045 1106
mbed_official 49:77c8e4604045 1107 pt->state = osTimerInvalid;
mbed_official 49:77c8e4604045 1108
mbed_official 49:77c8e4604045 1109 return osOK;
mbed_official 49:77c8e4604045 1110 }
mbed_official 49:77c8e4604045 1111
mbed_official 49:77c8e4604045 1112 /// Get timer callback parameters
mbed_official 49:77c8e4604045 1113 os_InRegs osCallback_type svcTimerCall (osTimerId timer_id) {
mbed_official 49:77c8e4604045 1114 os_timer_cb *pt;
mbed_official 49:77c8e4604045 1115 osCallback ret;
mbed_official 49:77c8e4604045 1116
mbed_official 49:77c8e4604045 1117 pt = rt_id2obj(timer_id);
mbed_official 49:77c8e4604045 1118 if (pt == NULL) {
mbed_official 49:77c8e4604045 1119 ret.fp = NULL;
mbed_official 49:77c8e4604045 1120 ret.arg = NULL;
mbed_official 49:77c8e4604045 1121 return osCallback_ret;
mbed_official 49:77c8e4604045 1122 }
mbed_official 49:77c8e4604045 1123
mbed_official 49:77c8e4604045 1124 ret.fp = (void *)pt->timer->ptimer;
mbed_official 49:77c8e4604045 1125 ret.arg = pt->arg;
mbed_official 49:77c8e4604045 1126
mbed_official 49:77c8e4604045 1127 return osCallback_ret;
mbed_official 49:77c8e4604045 1128 }
mbed_official 49:77c8e4604045 1129
mbed_official 112:53ace74b190c 1130 osStatus isrMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec);
mbed_official 49:77c8e4604045 1131
mbed_official 49:77c8e4604045 1132 /// Timer Tick (called each SysTick)
mbed_official 49:77c8e4604045 1133 void sysTimerTick (void) {
mbed_official 49:77c8e4604045 1134 os_timer_cb *pt, *p;
mbed_official 112:53ace74b190c 1135 osStatus status;
mbed_official 49:77c8e4604045 1136
mbed_official 49:77c8e4604045 1137 p = os_timer_head;
mbed_official 112:53ace74b190c 1138 if (p == NULL) { return; }
mbed_official 49:77c8e4604045 1139
mbed_official 49:77c8e4604045 1140 p->tcnt--;
mbed_official 112:53ace74b190c 1141 while ((p != NULL) && (p->tcnt == 0U)) {
mbed_official 49:77c8e4604045 1142 pt = p;
mbed_official 49:77c8e4604045 1143 p = p->next;
mbed_official 49:77c8e4604045 1144 os_timer_head = p;
mbed_official 112:53ace74b190c 1145 status = isrMessagePut(osMessageQId_osTimerMessageQ, (uint32_t)pt, 0U);
mbed_official 112:53ace74b190c 1146 if (status != osOK) {
mbed_official 112:53ace74b190c 1147 os_error(OS_ERR_TIMER_OVF);
mbed_official 112:53ace74b190c 1148 }
mbed_official 112:53ace74b190c 1149 if (pt->type == (uint8_t)osTimerPeriodic) {
mbed_official 49:77c8e4604045 1150 rt_timer_insert(pt, pt->icnt);
mbed_official 49:77c8e4604045 1151 } else {
mbed_official 49:77c8e4604045 1152 pt->state = osTimerStopped;
mbed_official 49:77c8e4604045 1153 }
mbed_official 49:77c8e4604045 1154 }
mbed_official 49:77c8e4604045 1155 }
mbed_official 49:77c8e4604045 1156
mbed_official 112:53ace74b190c 1157 /// Get user timers wake-up time
mbed_official 112:53ace74b190c 1158 uint32_t sysUserTimerWakeupTime (void) {
mbed_official 112:53ace74b190c 1159
mbed_official 112:53ace74b190c 1160 if (os_timer_head) {
mbed_official 112:53ace74b190c 1161 return os_timer_head->tcnt;
mbed_official 112:53ace74b190c 1162 }
mbed_official 112:53ace74b190c 1163 return 0xFFFFFFFFU;
mbed_official 112:53ace74b190c 1164 }
mbed_official 112:53ace74b190c 1165
mbed_official 112:53ace74b190c 1166 /// Update user timers on resume
mbed_official 112:53ace74b190c 1167 void sysUserTimerUpdate (uint32_t sleep_time) {
mbed_official 112:53ace74b190c 1168
mbed_official 112:53ace74b190c 1169 while ((os_timer_head != NULL) && (sleep_time != 0U)) {
mbed_official 112:53ace74b190c 1170 if (sleep_time >= os_timer_head->tcnt) {
mbed_official 112:53ace74b190c 1171 sleep_time -= os_timer_head->tcnt;
mbed_official 112:53ace74b190c 1172 os_timer_head->tcnt = 1U;
mbed_official 112:53ace74b190c 1173 sysTimerTick();
mbed_official 112:53ace74b190c 1174 } else {
mbed_official 112:53ace74b190c 1175 os_timer_head->tcnt -= sleep_time;
mbed_official 112:53ace74b190c 1176 break;
mbed_official 112:53ace74b190c 1177 }
mbed_official 112:53ace74b190c 1178 }
mbed_official 112:53ace74b190c 1179 }
mbed_official 112:53ace74b190c 1180
mbed_official 49:77c8e4604045 1181
mbed_official 49:77c8e4604045 1182 // Timer Management Public API
mbed_official 49:77c8e4604045 1183
mbed_official 49:77c8e4604045 1184 /// Create timer
mbed_official 112:53ace74b190c 1185 osTimerId osTimerCreate (const osTimerDef_t *timer_def, os_timer_type type, void *argument) {
mbed_official 112:53ace74b190c 1186 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1187 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 1188 }
mbed_official 112:53ace74b190c 1189 if (((__get_CONTROL() & 1U) == 0U) && (os_running == 0U)) {
mbed_official 49:77c8e4604045 1190 // Privileged and not running
mbed_official 49:77c8e4604045 1191 return svcTimerCreate(timer_def, type, argument);
mbed_official 49:77c8e4604045 1192 } else {
mbed_official 49:77c8e4604045 1193 return __svcTimerCreate(timer_def, type, argument);
mbed_official 49:77c8e4604045 1194 }
mbed_official 49:77c8e4604045 1195 }
mbed_official 49:77c8e4604045 1196
mbed_official 49:77c8e4604045 1197 /// Start or restart timer
mbed_official 49:77c8e4604045 1198 osStatus osTimerStart (osTimerId timer_id, uint32_t millisec) {
mbed_official 112:53ace74b190c 1199 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1200 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 1201 }
mbed_official 49:77c8e4604045 1202 return __svcTimerStart(timer_id, millisec);
mbed_official 49:77c8e4604045 1203 }
mbed_official 49:77c8e4604045 1204
mbed_official 49:77c8e4604045 1205 /// Stop timer
mbed_official 49:77c8e4604045 1206 osStatus osTimerStop (osTimerId timer_id) {
mbed_official 112:53ace74b190c 1207 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1208 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 1209 }
mbed_official 49:77c8e4604045 1210 return __svcTimerStop(timer_id);
mbed_official 49:77c8e4604045 1211 }
mbed_official 49:77c8e4604045 1212
mbed_official 49:77c8e4604045 1213 /// Delete timer
mbed_official 49:77c8e4604045 1214 osStatus osTimerDelete (osTimerId timer_id) {
mbed_official 112:53ace74b190c 1215 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1216 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 1217 }
mbed_official 49:77c8e4604045 1218 return __svcTimerDelete(timer_id);
mbed_official 49:77c8e4604045 1219 }
mbed_official 49:77c8e4604045 1220
mbed_official 49:77c8e4604045 1221 /// INTERNAL - Not Public
mbed_official 49:77c8e4604045 1222 /// Get timer callback parameters (used by OS Timer Thread)
mbed_official 112:53ace74b190c 1223 os_InRegs osCallback osTimerCall (osTimerId timer_id) {
mbed_official 112:53ace74b190c 1224 return __svcTimerCall(timer_id);
mbed_official 49:77c8e4604045 1225 }
mbed_official 49:77c8e4604045 1226
mbed_official 49:77c8e4604045 1227
mbed_official 49:77c8e4604045 1228 // Timer Thread
mbed_official 49:77c8e4604045 1229 __NO_RETURN void osTimerThread (void const *argument) {
mbed_official 49:77c8e4604045 1230 osCallback cb;
mbed_official 49:77c8e4604045 1231 osEvent evt;
mbed_official 49:77c8e4604045 1232
mbed_official 49:77c8e4604045 1233 for (;;) {
mbed_official 49:77c8e4604045 1234 evt = osMessageGet(osMessageQId_osTimerMessageQ, osWaitForever);
mbed_official 49:77c8e4604045 1235 if (evt.status == osEventMessage) {
mbed_official 49:77c8e4604045 1236 cb = osTimerCall(evt.value.p);
mbed_official 49:77c8e4604045 1237 if (cb.fp != NULL) {
mbed_official 49:77c8e4604045 1238 (*(os_ptimer)cb.fp)(cb.arg);
mbed_official 49:77c8e4604045 1239 }
mbed_official 49:77c8e4604045 1240 }
mbed_official 49:77c8e4604045 1241 }
mbed_official 49:77c8e4604045 1242 }
mbed_official 49:77c8e4604045 1243
mbed_official 49:77c8e4604045 1244
mbed_official 49:77c8e4604045 1245 // ==== Signal Management ====
mbed_official 49:77c8e4604045 1246
mbed_official 49:77c8e4604045 1247 // Signal Service Calls declarations
mbed_official 49:77c8e4604045 1248 SVC_2_1(svcSignalSet, int32_t, osThreadId, int32_t, RET_int32_t)
mbed_official 49:77c8e4604045 1249 SVC_2_1(svcSignalClear, int32_t, osThreadId, int32_t, RET_int32_t)
mbed_official 49:77c8e4604045 1250 SVC_2_3(svcSignalWait, os_InRegs osEvent, int32_t, uint32_t, RET_osEvent)
mbed_official 49:77c8e4604045 1251
mbed_official 49:77c8e4604045 1252 // Signal Service Calls
mbed_official 49:77c8e4604045 1253
mbed_official 49:77c8e4604045 1254 /// Set the specified Signal Flags of an active thread
mbed_official 49:77c8e4604045 1255 int32_t svcSignalSet (osThreadId thread_id, int32_t signals) {
mbed_official 49:77c8e4604045 1256 P_TCB ptcb;
mbed_official 49:77c8e4604045 1257 int32_t sig;
mbed_official 49:77c8e4604045 1258
mbed_official 49:77c8e4604045 1259 ptcb = rt_tid2ptcb(thread_id); // Get TCB pointer
mbed_official 112:53ace74b190c 1260 if (ptcb == NULL) {
mbed_official 112:53ace74b190c 1261 return (int32_t)0x80000000U;
mbed_official 112:53ace74b190c 1262 }
mbed_official 49:77c8e4604045 1263
mbed_official 112:53ace74b190c 1264 if ((uint32_t)signals & (0xFFFFFFFFU << osFeature_Signals)) {
mbed_official 112:53ace74b190c 1265 return (int32_t)0x80000000U;
mbed_official 112:53ace74b190c 1266 }
mbed_official 49:77c8e4604045 1267
mbed_official 112:53ace74b190c 1268 sig = (int32_t)ptcb->events; // Previous signal flags
mbed_official 112:53ace74b190c 1269
mbed_official 112:53ace74b190c 1270 rt_evt_set((uint16_t)signals, ptcb->task_id); // Set event flags
mbed_official 49:77c8e4604045 1271
mbed_official 49:77c8e4604045 1272 return sig;
mbed_official 49:77c8e4604045 1273 }
mbed_official 49:77c8e4604045 1274
mbed_official 49:77c8e4604045 1275 /// Clear the specified Signal Flags of an active thread
mbed_official 49:77c8e4604045 1276 int32_t svcSignalClear (osThreadId thread_id, int32_t signals) {
mbed_official 49:77c8e4604045 1277 P_TCB ptcb;
mbed_official 49:77c8e4604045 1278 int32_t sig;
mbed_official 49:77c8e4604045 1279
mbed_official 49:77c8e4604045 1280 ptcb = rt_tid2ptcb(thread_id); // Get TCB pointer
mbed_official 112:53ace74b190c 1281 if (ptcb == NULL) {
mbed_official 112:53ace74b190c 1282 return (int32_t)0x80000000U;
mbed_official 112:53ace74b190c 1283 }
mbed_official 49:77c8e4604045 1284
mbed_official 112:53ace74b190c 1285 if ((uint32_t)signals & (0xFFFFFFFFU << osFeature_Signals)) {
mbed_official 112:53ace74b190c 1286 return (int32_t)0x80000000U;
mbed_official 112:53ace74b190c 1287 }
mbed_official 49:77c8e4604045 1288
mbed_official 112:53ace74b190c 1289 sig = (int32_t)ptcb->events; // Previous signal flags
mbed_official 112:53ace74b190c 1290
mbed_official 112:53ace74b190c 1291 rt_evt_clr((uint16_t)signals, ptcb->task_id); // Clear event flags
mbed_official 49:77c8e4604045 1292
mbed_official 49:77c8e4604045 1293 return sig;
mbed_official 49:77c8e4604045 1294 }
mbed_official 49:77c8e4604045 1295
mbed_official 49:77c8e4604045 1296 /// Wait for one or more Signal Flags to become signaled for the current RUNNING thread
mbed_official 49:77c8e4604045 1297 os_InRegs osEvent_type svcSignalWait (int32_t signals, uint32_t millisec) {
mbed_official 49:77c8e4604045 1298 OS_RESULT res;
mbed_official 49:77c8e4604045 1299 osEvent ret;
mbed_official 49:77c8e4604045 1300
mbed_official 112:53ace74b190c 1301 if ((uint32_t)signals & (0xFFFFFFFFU << osFeature_Signals)) {
mbed_official 49:77c8e4604045 1302 ret.status = osErrorValue;
mbed_official 49:77c8e4604045 1303 return osEvent_ret_status;
mbed_official 49:77c8e4604045 1304 }
mbed_official 49:77c8e4604045 1305
mbed_official 49:77c8e4604045 1306 if (signals != 0) { // Wait for all specified signals
mbed_official 112:53ace74b190c 1307 res = rt_evt_wait((uint16_t)signals, rt_ms2tick(millisec), __TRUE);
mbed_official 49:77c8e4604045 1308 } else { // Wait for any signal
mbed_official 112:53ace74b190c 1309 res = rt_evt_wait(0xFFFFU, rt_ms2tick(millisec), __FALSE);
mbed_official 49:77c8e4604045 1310 }
mbed_official 49:77c8e4604045 1311
mbed_official 49:77c8e4604045 1312 if (res == OS_R_EVT) {
mbed_official 49:77c8e4604045 1313 ret.status = osEventSignal;
mbed_official 112:53ace74b190c 1314 ret.value.signals = (signals != 0) ? signals : (int32_t)os_tsk.run->waits;
mbed_official 49:77c8e4604045 1315 } else {
mbed_official 112:53ace74b190c 1316 ret.status = (millisec != 0U) ? osEventTimeout : osOK;
mbed_official 49:77c8e4604045 1317 ret.value.signals = 0;
mbed_official 49:77c8e4604045 1318 }
mbed_official 49:77c8e4604045 1319
mbed_official 49:77c8e4604045 1320 return osEvent_ret_value;
mbed_official 49:77c8e4604045 1321 }
mbed_official 49:77c8e4604045 1322
mbed_official 49:77c8e4604045 1323
mbed_official 49:77c8e4604045 1324 // Signal ISR Calls
mbed_official 49:77c8e4604045 1325
mbed_official 49:77c8e4604045 1326 /// Set the specified Signal Flags of an active thread
mbed_official 112:53ace74b190c 1327 int32_t isrSignalSet (osThreadId thread_id, int32_t signals) {
mbed_official 49:77c8e4604045 1328 P_TCB ptcb;
mbed_official 49:77c8e4604045 1329 int32_t sig;
mbed_official 49:77c8e4604045 1330
mbed_official 49:77c8e4604045 1331 ptcb = rt_tid2ptcb(thread_id); // Get TCB pointer
mbed_official 112:53ace74b190c 1332 if (ptcb == NULL) {
mbed_official 112:53ace74b190c 1333 return (int32_t)0x80000000U;
mbed_official 112:53ace74b190c 1334 }
mbed_official 49:77c8e4604045 1335
mbed_official 112:53ace74b190c 1336 if ((uint32_t)signals & (0xFFFFFFFFU << osFeature_Signals)) {
mbed_official 112:53ace74b190c 1337 return (int32_t)0x80000000U;
mbed_official 112:53ace74b190c 1338 }
mbed_official 49:77c8e4604045 1339
mbed_official 112:53ace74b190c 1340 sig = (int32_t)ptcb->events; // Previous signal flags
mbed_official 112:53ace74b190c 1341
mbed_official 112:53ace74b190c 1342 isr_evt_set((uint16_t)signals, ptcb->task_id);// Set event flags
mbed_official 49:77c8e4604045 1343
mbed_official 49:77c8e4604045 1344 return sig;
mbed_official 49:77c8e4604045 1345 }
mbed_official 49:77c8e4604045 1346
mbed_official 49:77c8e4604045 1347
mbed_official 49:77c8e4604045 1348 // Signal Public API
mbed_official 49:77c8e4604045 1349
mbed_official 49:77c8e4604045 1350 /// Set the specified Signal Flags of an active thread
mbed_official 49:77c8e4604045 1351 int32_t osSignalSet (osThreadId thread_id, int32_t signals) {
mbed_official 112:53ace74b190c 1352 if (__get_IPSR() != 0U) { // in ISR
mbed_official 112:53ace74b190c 1353 return isrSignalSet(thread_id, signals);
mbed_official 49:77c8e4604045 1354 } else { // in Thread
mbed_official 49:77c8e4604045 1355 return __svcSignalSet(thread_id, signals);
mbed_official 49:77c8e4604045 1356 }
mbed_official 49:77c8e4604045 1357 }
mbed_official 49:77c8e4604045 1358
mbed_official 49:77c8e4604045 1359 /// Clear the specified Signal Flags of an active thread
mbed_official 49:77c8e4604045 1360 int32_t osSignalClear (osThreadId thread_id, int32_t signals) {
mbed_official 112:53ace74b190c 1361 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1362 return (int32_t)0x80000000U; // Not allowed in ISR
mbed_official 112:53ace74b190c 1363 }
mbed_official 49:77c8e4604045 1364 return __svcSignalClear(thread_id, signals);
mbed_official 49:77c8e4604045 1365 }
mbed_official 49:77c8e4604045 1366
mbed_official 49:77c8e4604045 1367 /// Wait for one or more Signal Flags to become signaled for the current RUNNING thread
mbed_official 49:77c8e4604045 1368 os_InRegs osEvent osSignalWait (int32_t signals, uint32_t millisec) {
mbed_official 49:77c8e4604045 1369 osEvent ret;
mbed_official 49:77c8e4604045 1370
mbed_official 112:53ace74b190c 1371 if (__get_IPSR() != 0U) { // Not allowed in ISR
mbed_official 49:77c8e4604045 1372 ret.status = osErrorISR;
mbed_official 49:77c8e4604045 1373 return ret;
mbed_official 49:77c8e4604045 1374 }
mbed_official 49:77c8e4604045 1375 return __svcSignalWait(signals, millisec);
mbed_official 49:77c8e4604045 1376 }
mbed_official 49:77c8e4604045 1377
mbed_official 49:77c8e4604045 1378
mbed_official 49:77c8e4604045 1379 // ==== Mutex Management ====
mbed_official 49:77c8e4604045 1380
mbed_official 49:77c8e4604045 1381 // Mutex Service Calls declarations
mbed_official 112:53ace74b190c 1382 SVC_1_1(svcMutexCreate, osMutexId, const osMutexDef_t *, RET_pointer)
mbed_official 112:53ace74b190c 1383 SVC_2_1(svcMutexWait, osStatus, osMutexId, uint32_t, RET_osStatus)
mbed_official 112:53ace74b190c 1384 SVC_1_1(svcMutexRelease, osStatus, osMutexId, RET_osStatus)
mbed_official 112:53ace74b190c 1385 SVC_1_1(svcMutexDelete, osStatus, osMutexId, RET_osStatus)
mbed_official 49:77c8e4604045 1386
mbed_official 49:77c8e4604045 1387 // Mutex Service Calls
mbed_official 49:77c8e4604045 1388
mbed_official 49:77c8e4604045 1389 /// Create and Initialize a Mutex object
mbed_official 112:53ace74b190c 1390 osMutexId svcMutexCreate (const osMutexDef_t *mutex_def) {
mbed_official 49:77c8e4604045 1391 OS_ID mut;
mbed_official 49:77c8e4604045 1392
mbed_official 49:77c8e4604045 1393 if (mutex_def == NULL) {
mbed_official 49:77c8e4604045 1394 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1395 return NULL;
mbed_official 49:77c8e4604045 1396 }
mbed_official 49:77c8e4604045 1397
mbed_official 49:77c8e4604045 1398 mut = mutex_def->mutex;
mbed_official 49:77c8e4604045 1399 if (mut == NULL) {
mbed_official 49:77c8e4604045 1400 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1401 return NULL;
mbed_official 49:77c8e4604045 1402 }
mbed_official 49:77c8e4604045 1403
mbed_official 112:53ace74b190c 1404 if (((P_MUCB)mut)->cb_type != 0U) {
mbed_official 49:77c8e4604045 1405 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1406 return NULL;
mbed_official 49:77c8e4604045 1407 }
mbed_official 49:77c8e4604045 1408
mbed_official 49:77c8e4604045 1409 rt_mut_init(mut); // Initialize Mutex
mbed_official 49:77c8e4604045 1410
mbed_official 49:77c8e4604045 1411 return mut;
mbed_official 49:77c8e4604045 1412 }
mbed_official 49:77c8e4604045 1413
mbed_official 49:77c8e4604045 1414 /// Wait until a Mutex becomes available
mbed_official 49:77c8e4604045 1415 osStatus svcMutexWait (osMutexId mutex_id, uint32_t millisec) {
mbed_official 49:77c8e4604045 1416 OS_ID mut;
mbed_official 49:77c8e4604045 1417 OS_RESULT res;
mbed_official 49:77c8e4604045 1418
mbed_official 49:77c8e4604045 1419 mut = rt_id2obj(mutex_id);
mbed_official 112:53ace74b190c 1420 if (mut == NULL) {
mbed_official 112:53ace74b190c 1421 return osErrorParameter;
mbed_official 112:53ace74b190c 1422 }
mbed_official 49:77c8e4604045 1423
mbed_official 112:53ace74b190c 1424 if (((P_MUCB)mut)->cb_type != MUCB) {
mbed_official 112:53ace74b190c 1425 return osErrorParameter;
mbed_official 112:53ace74b190c 1426 }
mbed_official 49:77c8e4604045 1427
mbed_official 49:77c8e4604045 1428 res = rt_mut_wait(mut, rt_ms2tick(millisec)); // Wait for Mutex
mbed_official 49:77c8e4604045 1429
mbed_official 49:77c8e4604045 1430 if (res == OS_R_TMO) {
mbed_official 112:53ace74b190c 1431 return ((millisec != 0U) ? osErrorTimeoutResource : osErrorResource);
mbed_official 49:77c8e4604045 1432 }
mbed_official 49:77c8e4604045 1433
mbed_official 49:77c8e4604045 1434 return osOK;
mbed_official 49:77c8e4604045 1435 }
mbed_official 49:77c8e4604045 1436
mbed_official 49:77c8e4604045 1437 /// Release a Mutex that was obtained with osMutexWait
mbed_official 49:77c8e4604045 1438 osStatus svcMutexRelease (osMutexId mutex_id) {
mbed_official 49:77c8e4604045 1439 OS_ID mut;
mbed_official 49:77c8e4604045 1440 OS_RESULT res;
mbed_official 49:77c8e4604045 1441
mbed_official 49:77c8e4604045 1442 mut = rt_id2obj(mutex_id);
mbed_official 112:53ace74b190c 1443 if (mut == NULL) {
mbed_official 112:53ace74b190c 1444 return osErrorParameter;
mbed_official 112:53ace74b190c 1445 }
mbed_official 49:77c8e4604045 1446
mbed_official 112:53ace74b190c 1447 if (((P_MUCB)mut)->cb_type != MUCB) {
mbed_official 112:53ace74b190c 1448 return osErrorParameter;
mbed_official 112:53ace74b190c 1449 }
mbed_official 49:77c8e4604045 1450
mbed_official 49:77c8e4604045 1451 res = rt_mut_release(mut); // Release Mutex
mbed_official 49:77c8e4604045 1452
mbed_official 112:53ace74b190c 1453 if (res == OS_R_NOK) {
mbed_official 112:53ace74b190c 1454 return osErrorResource; // Thread not owner or Zero Counter
mbed_official 112:53ace74b190c 1455 }
mbed_official 49:77c8e4604045 1456
mbed_official 49:77c8e4604045 1457 return osOK;
mbed_official 49:77c8e4604045 1458 }
mbed_official 49:77c8e4604045 1459
mbed_official 49:77c8e4604045 1460 /// Delete a Mutex that was created by osMutexCreate
mbed_official 49:77c8e4604045 1461 osStatus svcMutexDelete (osMutexId mutex_id) {
mbed_official 49:77c8e4604045 1462 OS_ID mut;
mbed_official 49:77c8e4604045 1463
mbed_official 49:77c8e4604045 1464 mut = rt_id2obj(mutex_id);
mbed_official 112:53ace74b190c 1465 if (mut == NULL) {
mbed_official 112:53ace74b190c 1466 return osErrorParameter;
mbed_official 112:53ace74b190c 1467 }
mbed_official 49:77c8e4604045 1468
mbed_official 112:53ace74b190c 1469 if (((P_MUCB)mut)->cb_type != MUCB) {
mbed_official 112:53ace74b190c 1470 return osErrorParameter;
mbed_official 112:53ace74b190c 1471 }
mbed_official 49:77c8e4604045 1472
mbed_official 49:77c8e4604045 1473 rt_mut_delete(mut); // Release Mutex
mbed_official 49:77c8e4604045 1474
mbed_official 49:77c8e4604045 1475 return osOK;
mbed_official 49:77c8e4604045 1476 }
mbed_official 49:77c8e4604045 1477
mbed_official 49:77c8e4604045 1478
mbed_official 49:77c8e4604045 1479 // Mutex Public API
mbed_official 49:77c8e4604045 1480
mbed_official 49:77c8e4604045 1481 /// Create and Initialize a Mutex object
mbed_official 112:53ace74b190c 1482 osMutexId osMutexCreate (const osMutexDef_t *mutex_def) {
mbed_official 112:53ace74b190c 1483 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1484 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 1485 }
mbed_official 112:53ace74b190c 1486 if (((__get_CONTROL() & 1U) == 0U) && (os_running == 0U)) {
mbed_official 49:77c8e4604045 1487 // Privileged and not running
mbed_official 49:77c8e4604045 1488 return svcMutexCreate(mutex_def);
mbed_official 49:77c8e4604045 1489 } else {
mbed_official 49:77c8e4604045 1490 return __svcMutexCreate(mutex_def);
mbed_official 49:77c8e4604045 1491 }
mbed_official 49:77c8e4604045 1492 }
mbed_official 49:77c8e4604045 1493
mbed_official 49:77c8e4604045 1494 /// Wait until a Mutex becomes available
mbed_official 49:77c8e4604045 1495 osStatus osMutexWait (osMutexId mutex_id, uint32_t millisec) {
mbed_official 112:53ace74b190c 1496 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1497 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 1498 }
mbed_official 49:77c8e4604045 1499 return __svcMutexWait(mutex_id, millisec);
mbed_official 49:77c8e4604045 1500 }
mbed_official 49:77c8e4604045 1501
mbed_official 49:77c8e4604045 1502 /// Release a Mutex that was obtained with osMutexWait
mbed_official 49:77c8e4604045 1503 osStatus osMutexRelease (osMutexId mutex_id) {
mbed_official 112:53ace74b190c 1504 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1505 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 1506 }
mbed_official 49:77c8e4604045 1507 return __svcMutexRelease(mutex_id);
mbed_official 49:77c8e4604045 1508 }
mbed_official 49:77c8e4604045 1509
mbed_official 49:77c8e4604045 1510 /// Delete a Mutex that was created by osMutexCreate
mbed_official 49:77c8e4604045 1511 osStatus osMutexDelete (osMutexId mutex_id) {
mbed_official 112:53ace74b190c 1512 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1513 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 1514 }
mbed_official 49:77c8e4604045 1515 return __svcMutexDelete(mutex_id);
mbed_official 49:77c8e4604045 1516 }
mbed_official 49:77c8e4604045 1517
mbed_official 49:77c8e4604045 1518
mbed_official 49:77c8e4604045 1519 // ==== Semaphore Management ====
mbed_official 49:77c8e4604045 1520
mbed_official 49:77c8e4604045 1521 // Semaphore Service Calls declarations
mbed_official 49:77c8e4604045 1522 SVC_2_1(svcSemaphoreCreate, osSemaphoreId, const osSemaphoreDef_t *, int32_t, RET_pointer)
mbed_official 112:53ace74b190c 1523 SVC_2_1(svcSemaphoreWait, int32_t, osSemaphoreId, uint32_t, RET_int32_t)
mbed_official 112:53ace74b190c 1524 SVC_1_1(svcSemaphoreRelease, osStatus, osSemaphoreId, RET_osStatus)
mbed_official 49:77c8e4604045 1525 SVC_1_1(svcSemaphoreDelete, osStatus, osSemaphoreId, RET_osStatus)
mbed_official 49:77c8e4604045 1526
mbed_official 49:77c8e4604045 1527 // Semaphore Service Calls
mbed_official 49:77c8e4604045 1528
mbed_official 49:77c8e4604045 1529 /// Create and Initialize a Semaphore object
mbed_official 49:77c8e4604045 1530 osSemaphoreId svcSemaphoreCreate (const osSemaphoreDef_t *semaphore_def, int32_t count) {
mbed_official 49:77c8e4604045 1531 OS_ID sem;
mbed_official 49:77c8e4604045 1532
mbed_official 49:77c8e4604045 1533 if (semaphore_def == NULL) {
mbed_official 49:77c8e4604045 1534 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1535 return NULL;
mbed_official 49:77c8e4604045 1536 }
mbed_official 49:77c8e4604045 1537
mbed_official 49:77c8e4604045 1538 sem = semaphore_def->semaphore;
mbed_official 49:77c8e4604045 1539 if (sem == NULL) {
mbed_official 49:77c8e4604045 1540 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1541 return NULL;
mbed_official 49:77c8e4604045 1542 }
mbed_official 49:77c8e4604045 1543
mbed_official 112:53ace74b190c 1544 if (((P_SCB)sem)->cb_type != 0U) {
mbed_official 49:77c8e4604045 1545 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1546 return NULL;
mbed_official 49:77c8e4604045 1547 }
mbed_official 49:77c8e4604045 1548
mbed_official 49:77c8e4604045 1549 if (count > osFeature_Semaphore) {
mbed_official 49:77c8e4604045 1550 sysThreadError(osErrorValue);
mbed_official 49:77c8e4604045 1551 return NULL;
mbed_official 49:77c8e4604045 1552 }
mbed_official 49:77c8e4604045 1553
mbed_official 112:53ace74b190c 1554 rt_sem_init(sem, (uint16_t)count); // Initialize Semaphore
mbed_official 112:53ace74b190c 1555
mbed_official 49:77c8e4604045 1556 return sem;
mbed_official 49:77c8e4604045 1557 }
mbed_official 49:77c8e4604045 1558
mbed_official 49:77c8e4604045 1559 /// Wait until a Semaphore becomes available
mbed_official 49:77c8e4604045 1560 int32_t svcSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec) {
mbed_official 49:77c8e4604045 1561 OS_ID sem;
mbed_official 49:77c8e4604045 1562 OS_RESULT res;
mbed_official 49:77c8e4604045 1563
mbed_official 49:77c8e4604045 1564 sem = rt_id2obj(semaphore_id);
mbed_official 112:53ace74b190c 1565 if (sem == NULL) {
mbed_official 112:53ace74b190c 1566 return -1;
mbed_official 112:53ace74b190c 1567 }
mbed_official 49:77c8e4604045 1568
mbed_official 112:53ace74b190c 1569 if (((P_SCB)sem)->cb_type != SCB) {
mbed_official 112:53ace74b190c 1570 return -1;
mbed_official 112:53ace74b190c 1571 }
mbed_official 49:77c8e4604045 1572
mbed_official 49:77c8e4604045 1573 res = rt_sem_wait(sem, rt_ms2tick(millisec)); // Wait for Semaphore
mbed_official 49:77c8e4604045 1574
mbed_official 112:53ace74b190c 1575 if (res == OS_R_TMO) { return 0; } // Timeout
mbed_official 49:77c8e4604045 1576
mbed_official 112:53ace74b190c 1577 return (int32_t)(((P_SCB)sem)->tokens + 1U);
mbed_official 49:77c8e4604045 1578 }
mbed_official 49:77c8e4604045 1579
mbed_official 49:77c8e4604045 1580 /// Release a Semaphore
mbed_official 49:77c8e4604045 1581 osStatus svcSemaphoreRelease (osSemaphoreId semaphore_id) {
mbed_official 49:77c8e4604045 1582 OS_ID sem;
mbed_official 49:77c8e4604045 1583
mbed_official 49:77c8e4604045 1584 sem = rt_id2obj(semaphore_id);
mbed_official 112:53ace74b190c 1585 if (sem == NULL) {
mbed_official 112:53ace74b190c 1586 return osErrorParameter;
mbed_official 112:53ace74b190c 1587 }
mbed_official 49:77c8e4604045 1588
mbed_official 112:53ace74b190c 1589 if (((P_SCB)sem)->cb_type != SCB) {
mbed_official 112:53ace74b190c 1590 return osErrorParameter;
mbed_official 112:53ace74b190c 1591 }
mbed_official 49:77c8e4604045 1592
mbed_official 112:53ace74b190c 1593 if ((int32_t)((P_SCB)sem)->tokens == osFeature_Semaphore) {
mbed_official 112:53ace74b190c 1594 return osErrorResource;
mbed_official 112:53ace74b190c 1595 }
mbed_official 112:53ace74b190c 1596
mbed_official 49:77c8e4604045 1597 rt_sem_send(sem); // Release Semaphore
mbed_official 49:77c8e4604045 1598
mbed_official 49:77c8e4604045 1599 return osOK;
mbed_official 49:77c8e4604045 1600 }
mbed_official 49:77c8e4604045 1601
mbed_official 49:77c8e4604045 1602 /// Delete a Semaphore that was created by osSemaphoreCreate
mbed_official 49:77c8e4604045 1603 osStatus svcSemaphoreDelete (osSemaphoreId semaphore_id) {
mbed_official 49:77c8e4604045 1604 OS_ID sem;
mbed_official 49:77c8e4604045 1605
mbed_official 49:77c8e4604045 1606 sem = rt_id2obj(semaphore_id);
mbed_official 112:53ace74b190c 1607 if (sem == NULL) {
mbed_official 112:53ace74b190c 1608 return osErrorParameter;
mbed_official 112:53ace74b190c 1609 }
mbed_official 49:77c8e4604045 1610
mbed_official 112:53ace74b190c 1611 if (((P_SCB)sem)->cb_type != SCB) {
mbed_official 112:53ace74b190c 1612 return osErrorParameter;
mbed_official 112:53ace74b190c 1613 }
mbed_official 49:77c8e4604045 1614
mbed_official 49:77c8e4604045 1615 rt_sem_delete(sem); // Delete Semaphore
mbed_official 49:77c8e4604045 1616
mbed_official 49:77c8e4604045 1617 return osOK;
mbed_official 49:77c8e4604045 1618 }
mbed_official 49:77c8e4604045 1619
mbed_official 49:77c8e4604045 1620
mbed_official 49:77c8e4604045 1621 // Semaphore ISR Calls
mbed_official 49:77c8e4604045 1622
mbed_official 49:77c8e4604045 1623 /// Release a Semaphore
mbed_official 112:53ace74b190c 1624 osStatus isrSemaphoreRelease (osSemaphoreId semaphore_id) {
mbed_official 49:77c8e4604045 1625 OS_ID sem;
mbed_official 49:77c8e4604045 1626
mbed_official 49:77c8e4604045 1627 sem = rt_id2obj(semaphore_id);
mbed_official 112:53ace74b190c 1628 if (sem == NULL) {
mbed_official 112:53ace74b190c 1629 return osErrorParameter;
mbed_official 112:53ace74b190c 1630 }
mbed_official 49:77c8e4604045 1631
mbed_official 112:53ace74b190c 1632 if (((P_SCB)sem)->cb_type != SCB) {
mbed_official 112:53ace74b190c 1633 return osErrorParameter;
mbed_official 112:53ace74b190c 1634 }
mbed_official 49:77c8e4604045 1635
mbed_official 112:53ace74b190c 1636 if ((int32_t)((P_SCB)sem)->tokens == osFeature_Semaphore) {
mbed_official 112:53ace74b190c 1637 return osErrorResource;
mbed_official 112:53ace74b190c 1638 }
mbed_official 49:77c8e4604045 1639
mbed_official 49:77c8e4604045 1640 isr_sem_send(sem); // Release Semaphore
mbed_official 49:77c8e4604045 1641
mbed_official 49:77c8e4604045 1642 return osOK;
mbed_official 49:77c8e4604045 1643 }
mbed_official 49:77c8e4604045 1644
mbed_official 49:77c8e4604045 1645
mbed_official 49:77c8e4604045 1646 // Semaphore Public API
mbed_official 49:77c8e4604045 1647
mbed_official 49:77c8e4604045 1648 /// Create and Initialize a Semaphore object
mbed_official 112:53ace74b190c 1649 osSemaphoreId osSemaphoreCreate (const osSemaphoreDef_t *semaphore_def, int32_t count) {
mbed_official 112:53ace74b190c 1650 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1651 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 1652 }
mbed_official 112:53ace74b190c 1653 if (((__get_CONTROL() & 1U) == 0U) && (os_running == 0U)) {
mbed_official 49:77c8e4604045 1654 // Privileged and not running
mbed_official 49:77c8e4604045 1655 return svcSemaphoreCreate(semaphore_def, count);
mbed_official 49:77c8e4604045 1656 } else {
mbed_official 49:77c8e4604045 1657 return __svcSemaphoreCreate(semaphore_def, count);
mbed_official 49:77c8e4604045 1658 }
mbed_official 49:77c8e4604045 1659 }
mbed_official 49:77c8e4604045 1660
mbed_official 49:77c8e4604045 1661 /// Wait until a Semaphore becomes available
mbed_official 49:77c8e4604045 1662 int32_t osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec) {
mbed_official 112:53ace74b190c 1663 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1664 return -1; // Not allowed in ISR
mbed_official 112:53ace74b190c 1665 }
mbed_official 49:77c8e4604045 1666 return __svcSemaphoreWait(semaphore_id, millisec);
mbed_official 49:77c8e4604045 1667 }
mbed_official 49:77c8e4604045 1668
mbed_official 49:77c8e4604045 1669 /// Release a Semaphore
mbed_official 49:77c8e4604045 1670 osStatus osSemaphoreRelease (osSemaphoreId semaphore_id) {
mbed_official 112:53ace74b190c 1671 if (__get_IPSR() != 0U) { // in ISR
mbed_official 49:77c8e4604045 1672 return isrSemaphoreRelease(semaphore_id);
mbed_official 49:77c8e4604045 1673 } else { // in Thread
mbed_official 49:77c8e4604045 1674 return __svcSemaphoreRelease(semaphore_id);
mbed_official 49:77c8e4604045 1675 }
mbed_official 49:77c8e4604045 1676 }
mbed_official 49:77c8e4604045 1677
mbed_official 49:77c8e4604045 1678 /// Delete a Semaphore that was created by osSemaphoreCreate
mbed_official 49:77c8e4604045 1679 osStatus osSemaphoreDelete (osSemaphoreId semaphore_id) {
mbed_official 112:53ace74b190c 1680 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1681 return osErrorISR; // Not allowed in ISR
mbed_official 112:53ace74b190c 1682 }
mbed_official 49:77c8e4604045 1683 return __svcSemaphoreDelete(semaphore_id);
mbed_official 49:77c8e4604045 1684 }
mbed_official 49:77c8e4604045 1685
mbed_official 49:77c8e4604045 1686
mbed_official 49:77c8e4604045 1687 // ==== Memory Management Functions ====
mbed_official 49:77c8e4604045 1688
mbed_official 49:77c8e4604045 1689 // Memory Management Helper Functions
mbed_official 49:77c8e4604045 1690
mbed_official 49:77c8e4604045 1691 // Clear Memory Box (Zero init)
mbed_official 49:77c8e4604045 1692 static void rt_clr_box (void *box_mem, void *box) {
mbed_official 49:77c8e4604045 1693 uint32_t *p, n;
mbed_official 49:77c8e4604045 1694
mbed_official 112:53ace74b190c 1695 if ((box_mem != NULL) && (box != NULL)) {
mbed_official 49:77c8e4604045 1696 p = box;
mbed_official 112:53ace74b190c 1697 for (n = ((P_BM)box_mem)->blk_size; n; n -= 4U) {
mbed_official 112:53ace74b190c 1698 *p++ = 0U;
mbed_official 49:77c8e4604045 1699 }
mbed_official 49:77c8e4604045 1700 }
mbed_official 49:77c8e4604045 1701 }
mbed_official 49:77c8e4604045 1702
mbed_official 49:77c8e4604045 1703 // Memory Management Service Calls declarations
mbed_official 112:53ace74b190c 1704 SVC_1_1(svcPoolCreate, osPoolId, const osPoolDef_t *, RET_pointer)
mbed_official 112:53ace74b190c 1705 SVC_1_1(sysPoolAlloc, void *, osPoolId, RET_pointer)
mbed_official 112:53ace74b190c 1706 SVC_2_1(sysPoolFree, osStatus, osPoolId, void *, RET_osStatus)
mbed_official 49:77c8e4604045 1707
mbed_official 49:77c8e4604045 1708 // Memory Management Service & ISR Calls
mbed_official 49:77c8e4604045 1709
mbed_official 49:77c8e4604045 1710 /// Create and Initialize memory pool
mbed_official 49:77c8e4604045 1711 osPoolId svcPoolCreate (const osPoolDef_t *pool_def) {
mbed_official 49:77c8e4604045 1712 uint32_t blk_sz;
mbed_official 49:77c8e4604045 1713
mbed_official 49:77c8e4604045 1714 if ((pool_def == NULL) ||
mbed_official 112:53ace74b190c 1715 (pool_def->pool_sz == 0U) ||
mbed_official 112:53ace74b190c 1716 (pool_def->item_sz == 0U) ||
mbed_official 49:77c8e4604045 1717 (pool_def->pool == NULL)) {
mbed_official 49:77c8e4604045 1718 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1719 return NULL;
mbed_official 49:77c8e4604045 1720 }
mbed_official 49:77c8e4604045 1721
mbed_official 112:53ace74b190c 1722 blk_sz = (pool_def->item_sz + 3U) & (uint32_t)~3U;
mbed_official 49:77c8e4604045 1723
mbed_official 112:53ace74b190c 1724 _init_box(pool_def->pool, sizeof(struct OS_BM) + (pool_def->pool_sz * blk_sz), blk_sz);
mbed_official 49:77c8e4604045 1725
mbed_official 49:77c8e4604045 1726 return pool_def->pool;
mbed_official 49:77c8e4604045 1727 }
mbed_official 49:77c8e4604045 1728
mbed_official 49:77c8e4604045 1729 /// Allocate a memory block from a memory pool
mbed_official 112:53ace74b190c 1730 void *sysPoolAlloc (osPoolId pool_id) {
mbed_official 112:53ace74b190c 1731 void *mem;
mbed_official 49:77c8e4604045 1732
mbed_official 112:53ace74b190c 1733 if (pool_id == NULL) {
mbed_official 112:53ace74b190c 1734 return NULL;
mbed_official 49:77c8e4604045 1735 }
mbed_official 49:77c8e4604045 1736
mbed_official 112:53ace74b190c 1737 mem = rt_alloc_box(pool_id);
mbed_official 112:53ace74b190c 1738
mbed_official 112:53ace74b190c 1739 return mem;
mbed_official 49:77c8e4604045 1740 }
mbed_official 49:77c8e4604045 1741
mbed_official 49:77c8e4604045 1742 /// Return an allocated memory block back to a specific memory pool
mbed_official 49:77c8e4604045 1743 osStatus sysPoolFree (osPoolId pool_id, void *block) {
mbed_official 112:53ace74b190c 1744 uint32_t res;
mbed_official 112:53ace74b190c 1745
mbed_official 112:53ace74b190c 1746 if (pool_id == NULL) {
mbed_official 112:53ace74b190c 1747 return osErrorParameter;
mbed_official 112:53ace74b190c 1748 }
mbed_official 49:77c8e4604045 1749
mbed_official 49:77c8e4604045 1750 res = rt_free_box(pool_id, block);
mbed_official 112:53ace74b190c 1751 if (res != 0) {
mbed_official 112:53ace74b190c 1752 return osErrorValue;
mbed_official 112:53ace74b190c 1753 }
mbed_official 49:77c8e4604045 1754
mbed_official 49:77c8e4604045 1755 return osOK;
mbed_official 49:77c8e4604045 1756 }
mbed_official 49:77c8e4604045 1757
mbed_official 49:77c8e4604045 1758
mbed_official 49:77c8e4604045 1759 // Memory Management Public API
mbed_official 49:77c8e4604045 1760
mbed_official 49:77c8e4604045 1761 /// Create and Initialize memory pool
mbed_official 112:53ace74b190c 1762 osPoolId osPoolCreate (const osPoolDef_t *pool_def) {
mbed_official 112:53ace74b190c 1763 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1764 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 1765 }
mbed_official 112:53ace74b190c 1766 if (((__get_CONTROL() & 1U) == 0U) && (os_running == 0U)) {
mbed_official 49:77c8e4604045 1767 // Privileged and not running
mbed_official 49:77c8e4604045 1768 return svcPoolCreate(pool_def);
mbed_official 49:77c8e4604045 1769 } else {
mbed_official 49:77c8e4604045 1770 return __svcPoolCreate(pool_def);
mbed_official 49:77c8e4604045 1771 }
mbed_official 49:77c8e4604045 1772 }
mbed_official 49:77c8e4604045 1773
mbed_official 49:77c8e4604045 1774 /// Allocate a memory block from a memory pool
mbed_official 49:77c8e4604045 1775 void *osPoolAlloc (osPoolId pool_id) {
mbed_official 112:53ace74b190c 1776 if ((__get_IPSR() != 0U) || ((__get_CONTROL() & 1U) == 0U)) { // in ISR or Privileged
mbed_official 112:53ace74b190c 1777 return sysPoolAlloc(pool_id);
mbed_official 49:77c8e4604045 1778 } else { // in Thread
mbed_official 112:53ace74b190c 1779 return __sysPoolAlloc(pool_id);
mbed_official 49:77c8e4604045 1780 }
mbed_official 49:77c8e4604045 1781 }
mbed_official 49:77c8e4604045 1782
mbed_official 49:77c8e4604045 1783 /// Allocate a memory block from a memory pool and set memory block to zero
mbed_official 49:77c8e4604045 1784 void *osPoolCAlloc (osPoolId pool_id) {
mbed_official 112:53ace74b190c 1785 void *mem;
mbed_official 112:53ace74b190c 1786
mbed_official 112:53ace74b190c 1787 if ((__get_IPSR() != 0U) || ((__get_CONTROL() & 1U) == 0U)) { // in ISR or Privileged
mbed_official 112:53ace74b190c 1788 mem = sysPoolAlloc(pool_id);
mbed_official 49:77c8e4604045 1789 } else { // in Thread
mbed_official 112:53ace74b190c 1790 mem = __sysPoolAlloc(pool_id);
mbed_official 49:77c8e4604045 1791 }
mbed_official 112:53ace74b190c 1792
mbed_official 112:53ace74b190c 1793 rt_clr_box(pool_id, mem);
mbed_official 112:53ace74b190c 1794
mbed_official 112:53ace74b190c 1795 return mem;
mbed_official 49:77c8e4604045 1796 }
mbed_official 49:77c8e4604045 1797
mbed_official 49:77c8e4604045 1798 /// Return an allocated memory block back to a specific memory pool
mbed_official 49:77c8e4604045 1799 osStatus osPoolFree (osPoolId pool_id, void *block) {
mbed_official 112:53ace74b190c 1800 if ((__get_IPSR() != 0U) || ((__get_CONTROL() & 1U) == 0U)) { // in ISR or Privileged
mbed_official 49:77c8e4604045 1801 return sysPoolFree(pool_id, block);
mbed_official 49:77c8e4604045 1802 } else { // in Thread
mbed_official 49:77c8e4604045 1803 return __sysPoolFree(pool_id, block);
mbed_official 49:77c8e4604045 1804 }
mbed_official 49:77c8e4604045 1805 }
mbed_official 49:77c8e4604045 1806
mbed_official 49:77c8e4604045 1807
mbed_official 49:77c8e4604045 1808 // ==== Message Queue Management Functions ====
mbed_official 49:77c8e4604045 1809
mbed_official 49:77c8e4604045 1810 // Message Queue Management Service Calls declarations
mbed_official 112:53ace74b190c 1811 SVC_2_1(svcMessageCreate, osMessageQId, const osMessageQDef_t *, osThreadId, RET_pointer)
mbed_official 112:53ace74b190c 1812 SVC_3_1(svcMessagePut, osStatus, osMessageQId, uint32_t, uint32_t, RET_osStatus)
mbed_official 112:53ace74b190c 1813 SVC_2_3(svcMessageGet, os_InRegs osEvent, osMessageQId, uint32_t, RET_osEvent)
mbed_official 49:77c8e4604045 1814
mbed_official 49:77c8e4604045 1815 // Message Queue Service Calls
mbed_official 49:77c8e4604045 1816
mbed_official 49:77c8e4604045 1817 /// Create and Initialize Message Queue
mbed_official 112:53ace74b190c 1818 osMessageQId svcMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id) {
mbed_official 49:77c8e4604045 1819
mbed_official 49:77c8e4604045 1820 if ((queue_def == NULL) ||
mbed_official 112:53ace74b190c 1821 (queue_def->queue_sz == 0U) ||
mbed_official 49:77c8e4604045 1822 (queue_def->pool == NULL)) {
mbed_official 49:77c8e4604045 1823 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1824 return NULL;
mbed_official 49:77c8e4604045 1825 }
mbed_official 112:53ace74b190c 1826
mbed_official 112:53ace74b190c 1827 if (((P_MCB)queue_def->pool)->cb_type != 0U) {
mbed_official 49:77c8e4604045 1828 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1829 return NULL;
mbed_official 49:77c8e4604045 1830 }
mbed_official 49:77c8e4604045 1831
mbed_official 112:53ace74b190c 1832 rt_mbx_init(queue_def->pool, (uint16_t)(4U*(queue_def->queue_sz + 4U)));
mbed_official 49:77c8e4604045 1833
mbed_official 49:77c8e4604045 1834 return queue_def->pool;
mbed_official 49:77c8e4604045 1835 }
mbed_official 49:77c8e4604045 1836
mbed_official 49:77c8e4604045 1837 /// Put a Message to a Queue
mbed_official 49:77c8e4604045 1838 osStatus svcMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec) {
mbed_official 49:77c8e4604045 1839 OS_RESULT res;
mbed_official 49:77c8e4604045 1840
mbed_official 112:53ace74b190c 1841 if (queue_id == NULL) {
mbed_official 112:53ace74b190c 1842 return osErrorParameter;
mbed_official 112:53ace74b190c 1843 }
mbed_official 49:77c8e4604045 1844
mbed_official 112:53ace74b190c 1845 if (((P_MCB)queue_id)->cb_type != MCB) {
mbed_official 112:53ace74b190c 1846 return osErrorParameter;
mbed_official 112:53ace74b190c 1847 }
mbed_official 49:77c8e4604045 1848
mbed_official 49:77c8e4604045 1849 res = rt_mbx_send(queue_id, (void *)info, rt_ms2tick(millisec));
mbed_official 49:77c8e4604045 1850
mbed_official 49:77c8e4604045 1851 if (res == OS_R_TMO) {
mbed_official 112:53ace74b190c 1852 return ((millisec != 0U) ? osErrorTimeoutResource : osErrorResource);
mbed_official 49:77c8e4604045 1853 }
mbed_official 49:77c8e4604045 1854
mbed_official 49:77c8e4604045 1855 return osOK;
mbed_official 49:77c8e4604045 1856 }
mbed_official 49:77c8e4604045 1857
mbed_official 49:77c8e4604045 1858 /// Get a Message or Wait for a Message from a Queue
mbed_official 49:77c8e4604045 1859 os_InRegs osEvent_type svcMessageGet (osMessageQId queue_id, uint32_t millisec) {
mbed_official 49:77c8e4604045 1860 OS_RESULT res;
mbed_official 49:77c8e4604045 1861 osEvent ret;
mbed_official 49:77c8e4604045 1862
mbed_official 49:77c8e4604045 1863 if (queue_id == NULL) {
mbed_official 49:77c8e4604045 1864 ret.status = osErrorParameter;
mbed_official 49:77c8e4604045 1865 return osEvent_ret_status;
mbed_official 49:77c8e4604045 1866 }
mbed_official 49:77c8e4604045 1867
mbed_official 49:77c8e4604045 1868 if (((P_MCB)queue_id)->cb_type != MCB) {
mbed_official 49:77c8e4604045 1869 ret.status = osErrorParameter;
mbed_official 49:77c8e4604045 1870 return osEvent_ret_status;
mbed_official 49:77c8e4604045 1871 }
mbed_official 49:77c8e4604045 1872
mbed_official 49:77c8e4604045 1873 res = rt_mbx_wait(queue_id, &ret.value.p, rt_ms2tick(millisec));
mbed_official 112:53ace74b190c 1874
mbed_official 49:77c8e4604045 1875 if (res == OS_R_TMO) {
mbed_official 112:53ace74b190c 1876 ret.status = (millisec != 0U) ? osEventTimeout : osOK;
mbed_official 49:77c8e4604045 1877 return osEvent_ret_value;
mbed_official 49:77c8e4604045 1878 }
mbed_official 49:77c8e4604045 1879
mbed_official 49:77c8e4604045 1880 ret.status = osEventMessage;
mbed_official 49:77c8e4604045 1881
mbed_official 49:77c8e4604045 1882 return osEvent_ret_value;
mbed_official 49:77c8e4604045 1883 }
mbed_official 49:77c8e4604045 1884
mbed_official 49:77c8e4604045 1885
mbed_official 49:77c8e4604045 1886 // Message Queue ISR Calls
mbed_official 49:77c8e4604045 1887
mbed_official 49:77c8e4604045 1888 /// Put a Message to a Queue
mbed_official 112:53ace74b190c 1889 osStatus isrMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec) {
mbed_official 49:77c8e4604045 1890
mbed_official 112:53ace74b190c 1891 if ((queue_id == NULL) || (millisec != 0U)) {
mbed_official 49:77c8e4604045 1892 return osErrorParameter;
mbed_official 49:77c8e4604045 1893 }
mbed_official 49:77c8e4604045 1894
mbed_official 112:53ace74b190c 1895 if (((P_MCB)queue_id)->cb_type != MCB) {
mbed_official 112:53ace74b190c 1896 return osErrorParameter;
mbed_official 112:53ace74b190c 1897 }
mbed_official 49:77c8e4604045 1898
mbed_official 112:53ace74b190c 1899 if (rt_mbx_check(queue_id) == 0U) { // Check if Queue is full
mbed_official 49:77c8e4604045 1900 return osErrorResource;
mbed_official 49:77c8e4604045 1901 }
mbed_official 49:77c8e4604045 1902
mbed_official 49:77c8e4604045 1903 isr_mbx_send(queue_id, (void *)info);
mbed_official 49:77c8e4604045 1904
mbed_official 49:77c8e4604045 1905 return osOK;
mbed_official 49:77c8e4604045 1906 }
mbed_official 49:77c8e4604045 1907
mbed_official 49:77c8e4604045 1908 /// Get a Message or Wait for a Message from a Queue
mbed_official 112:53ace74b190c 1909 os_InRegs osEvent isrMessageGet (osMessageQId queue_id, uint32_t millisec) {
mbed_official 49:77c8e4604045 1910 OS_RESULT res;
mbed_official 49:77c8e4604045 1911 osEvent ret;
mbed_official 49:77c8e4604045 1912
mbed_official 112:53ace74b190c 1913 if ((queue_id == NULL) || (millisec != 0U)) {
mbed_official 49:77c8e4604045 1914 ret.status = osErrorParameter;
mbed_official 49:77c8e4604045 1915 return ret;
mbed_official 49:77c8e4604045 1916 }
mbed_official 49:77c8e4604045 1917
mbed_official 49:77c8e4604045 1918 if (((P_MCB)queue_id)->cb_type != MCB) {
mbed_official 49:77c8e4604045 1919 ret.status = osErrorParameter;
mbed_official 49:77c8e4604045 1920 return ret;
mbed_official 49:77c8e4604045 1921 }
mbed_official 49:77c8e4604045 1922
mbed_official 49:77c8e4604045 1923 res = isr_mbx_receive(queue_id, &ret.value.p);
mbed_official 112:53ace74b190c 1924
mbed_official 49:77c8e4604045 1925 if (res != OS_R_MBX) {
mbed_official 49:77c8e4604045 1926 ret.status = osOK;
mbed_official 49:77c8e4604045 1927 return ret;
mbed_official 49:77c8e4604045 1928 }
mbed_official 49:77c8e4604045 1929
mbed_official 112:53ace74b190c 1930 ret.status = osEventMessage;
mbed_official 49:77c8e4604045 1931
mbed_official 49:77c8e4604045 1932 return ret;
mbed_official 49:77c8e4604045 1933 }
mbed_official 49:77c8e4604045 1934
mbed_official 49:77c8e4604045 1935
mbed_official 49:77c8e4604045 1936 // Message Queue Management Public API
mbed_official 49:77c8e4604045 1937
mbed_official 49:77c8e4604045 1938 /// Create and Initialize Message Queue
mbed_official 112:53ace74b190c 1939 osMessageQId osMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id) {
mbed_official 112:53ace74b190c 1940 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 1941 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 1942 }
mbed_official 112:53ace74b190c 1943 if (((__get_CONTROL() & 1U) == 0U) && (os_running == 0U)) {
mbed_official 49:77c8e4604045 1944 // Privileged and not running
mbed_official 49:77c8e4604045 1945 return svcMessageCreate(queue_def, thread_id);
mbed_official 49:77c8e4604045 1946 } else {
mbed_official 49:77c8e4604045 1947 return __svcMessageCreate(queue_def, thread_id);
mbed_official 49:77c8e4604045 1948 }
mbed_official 49:77c8e4604045 1949 }
mbed_official 49:77c8e4604045 1950
mbed_official 49:77c8e4604045 1951 /// Put a Message to a Queue
mbed_official 49:77c8e4604045 1952 osStatus osMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec) {
mbed_official 112:53ace74b190c 1953 if (__get_IPSR() != 0U) { // in ISR
mbed_official 49:77c8e4604045 1954 return isrMessagePut(queue_id, info, millisec);
mbed_official 49:77c8e4604045 1955 } else { // in Thread
mbed_official 49:77c8e4604045 1956 return __svcMessagePut(queue_id, info, millisec);
mbed_official 49:77c8e4604045 1957 }
mbed_official 49:77c8e4604045 1958 }
mbed_official 49:77c8e4604045 1959
mbed_official 49:77c8e4604045 1960 /// Get a Message or Wait for a Message from a Queue
mbed_official 49:77c8e4604045 1961 os_InRegs osEvent osMessageGet (osMessageQId queue_id, uint32_t millisec) {
mbed_official 112:53ace74b190c 1962 if (__get_IPSR() != 0U) { // in ISR
mbed_official 49:77c8e4604045 1963 return isrMessageGet(queue_id, millisec);
mbed_official 49:77c8e4604045 1964 } else { // in Thread
mbed_official 49:77c8e4604045 1965 return __svcMessageGet(queue_id, millisec);
mbed_official 49:77c8e4604045 1966 }
mbed_official 49:77c8e4604045 1967 }
mbed_official 49:77c8e4604045 1968
mbed_official 49:77c8e4604045 1969
mbed_official 49:77c8e4604045 1970 // ==== Mail Queue Management Functions ====
mbed_official 49:77c8e4604045 1971
mbed_official 49:77c8e4604045 1972 // Mail Queue Management Service Calls declarations
mbed_official 112:53ace74b190c 1973 SVC_2_1(svcMailCreate, osMailQId, const osMailQDef_t *, osThreadId, RET_pointer)
mbed_official 112:53ace74b190c 1974 SVC_3_1(sysMailAlloc, void *, osMailQId, uint32_t, uint32_t, RET_pointer)
mbed_official 112:53ace74b190c 1975 SVC_3_1(sysMailFree, osStatus, osMailQId, void *, uint32_t, RET_osStatus)
mbed_official 49:77c8e4604045 1976
mbed_official 49:77c8e4604045 1977 // Mail Queue Management Service & ISR Calls
mbed_official 49:77c8e4604045 1978
mbed_official 49:77c8e4604045 1979 /// Create and Initialize mail queue
mbed_official 112:53ace74b190c 1980 osMailQId svcMailCreate (const osMailQDef_t *queue_def, osThreadId thread_id) {
mbed_official 49:77c8e4604045 1981 uint32_t blk_sz;
mbed_official 49:77c8e4604045 1982 P_MCB pmcb;
mbed_official 49:77c8e4604045 1983 void *pool;
mbed_official 49:77c8e4604045 1984
mbed_official 49:77c8e4604045 1985 if ((queue_def == NULL) ||
mbed_official 112:53ace74b190c 1986 (queue_def->queue_sz == 0U) ||
mbed_official 112:53ace74b190c 1987 (queue_def->item_sz == 0U) ||
mbed_official 49:77c8e4604045 1988 (queue_def->pool == NULL)) {
mbed_official 49:77c8e4604045 1989 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1990 return NULL;
mbed_official 49:77c8e4604045 1991 }
mbed_official 49:77c8e4604045 1992
mbed_official 49:77c8e4604045 1993 pmcb = *(((void **)queue_def->pool) + 0);
mbed_official 49:77c8e4604045 1994 pool = *(((void **)queue_def->pool) + 1);
mbed_official 49:77c8e4604045 1995
mbed_official 112:53ace74b190c 1996 if ((pool == NULL) || (pmcb == NULL) || (pmcb->cb_type != 0U)) {
mbed_official 49:77c8e4604045 1997 sysThreadError(osErrorParameter);
mbed_official 49:77c8e4604045 1998 return NULL;
mbed_official 49:77c8e4604045 1999 }
mbed_official 49:77c8e4604045 2000
mbed_official 112:53ace74b190c 2001 blk_sz = (queue_def->item_sz + 3U) & (uint32_t)~3U;
mbed_official 49:77c8e4604045 2002
mbed_official 112:53ace74b190c 2003 _init_box(pool, sizeof(struct OS_BM) + (queue_def->queue_sz * blk_sz), blk_sz);
mbed_official 49:77c8e4604045 2004
mbed_official 112:53ace74b190c 2005 rt_mbx_init(pmcb, (uint16_t)(4U*(queue_def->queue_sz + 4U)));
mbed_official 49:77c8e4604045 2006
mbed_official 49:77c8e4604045 2007 return queue_def->pool;
mbed_official 49:77c8e4604045 2008 }
mbed_official 49:77c8e4604045 2009
mbed_official 49:77c8e4604045 2010 /// Allocate a memory block from a mail
mbed_official 112:53ace74b190c 2011 void *sysMailAlloc (osMailQId queue_id, uint32_t millisec, uint32_t isr) {
mbed_official 49:77c8e4604045 2012 P_MCB pmcb;
mbed_official 49:77c8e4604045 2013 void *pool;
mbed_official 49:77c8e4604045 2014 void *mem;
mbed_official 49:77c8e4604045 2015
mbed_official 112:53ace74b190c 2016 if (queue_id == NULL) {
mbed_official 112:53ace74b190c 2017 return NULL;
mbed_official 112:53ace74b190c 2018 }
mbed_official 49:77c8e4604045 2019
mbed_official 49:77c8e4604045 2020 pmcb = *(((void **)queue_id) + 0);
mbed_official 49:77c8e4604045 2021 pool = *(((void **)queue_id) + 1);
mbed_official 49:77c8e4604045 2022
mbed_official 112:53ace74b190c 2023 if ((pool == NULL) || (pmcb == NULL)) {
mbed_official 112:53ace74b190c 2024 return NULL;
mbed_official 112:53ace74b190c 2025 }
mbed_official 49:77c8e4604045 2026
mbed_official 112:53ace74b190c 2027 if ((isr != 0U) && (millisec != 0U)) {
mbed_official 112:53ace74b190c 2028 return NULL;
mbed_official 112:53ace74b190c 2029 }
mbed_official 49:77c8e4604045 2030
mbed_official 49:77c8e4604045 2031 mem = rt_alloc_box(pool);
mbed_official 49:77c8e4604045 2032
mbed_official 112:53ace74b190c 2033 if ((mem == NULL) && (millisec != 0U)) {
mbed_official 49:77c8e4604045 2034 // Put Task to sleep when Memory not available
mbed_official 49:77c8e4604045 2035 if (pmcb->p_lnk != NULL) {
mbed_official 49:77c8e4604045 2036 rt_put_prio((P_XCB)pmcb, os_tsk.run);
mbed_official 49:77c8e4604045 2037 } else {
mbed_official 49:77c8e4604045 2038 pmcb->p_lnk = os_tsk.run;
mbed_official 49:77c8e4604045 2039 os_tsk.run->p_lnk = NULL;
mbed_official 49:77c8e4604045 2040 os_tsk.run->p_rlnk = (P_TCB)pmcb;
mbed_official 49:77c8e4604045 2041 // Task is waiting to allocate a message
mbed_official 112:53ace74b190c 2042 pmcb->state = 3U;
mbed_official 49:77c8e4604045 2043 }
mbed_official 49:77c8e4604045 2044 rt_block(rt_ms2tick(millisec), WAIT_MBX);
mbed_official 49:77c8e4604045 2045 }
mbed_official 49:77c8e4604045 2046
mbed_official 112:53ace74b190c 2047 return mem;
mbed_official 49:77c8e4604045 2048 }
mbed_official 49:77c8e4604045 2049
mbed_official 49:77c8e4604045 2050 /// Free a memory block from a mail
mbed_official 49:77c8e4604045 2051 osStatus sysMailFree (osMailQId queue_id, void *mail, uint32_t isr) {
mbed_official 112:53ace74b190c 2052 P_MCB pmcb;
mbed_official 112:53ace74b190c 2053 P_TCB ptcb;
mbed_official 112:53ace74b190c 2054 void *pool;
mbed_official 112:53ace74b190c 2055 void *mem;
mbed_official 112:53ace74b190c 2056 uint32_t res;
mbed_official 49:77c8e4604045 2057
mbed_official 112:53ace74b190c 2058 if (queue_id == NULL) {
mbed_official 112:53ace74b190c 2059 return osErrorParameter;
mbed_official 112:53ace74b190c 2060 }
mbed_official 49:77c8e4604045 2061
mbed_official 49:77c8e4604045 2062 pmcb = *(((void **)queue_id) + 0);
mbed_official 49:77c8e4604045 2063 pool = *(((void **)queue_id) + 1);
mbed_official 49:77c8e4604045 2064
mbed_official 112:53ace74b190c 2065 if ((pmcb == NULL) || (pool == NULL)) {
mbed_official 112:53ace74b190c 2066 return osErrorParameter;
mbed_official 112:53ace74b190c 2067 }
mbed_official 49:77c8e4604045 2068
mbed_official 49:77c8e4604045 2069 res = rt_free_box(pool, mail);
mbed_official 49:77c8e4604045 2070
mbed_official 112:53ace74b190c 2071 if (res != 0U) {
mbed_official 112:53ace74b190c 2072 return osErrorValue;
mbed_official 112:53ace74b190c 2073 }
mbed_official 49:77c8e4604045 2074
mbed_official 112:53ace74b190c 2075 if ((pmcb->p_lnk != NULL) && (pmcb->state == 3U)) {
mbed_official 49:77c8e4604045 2076 // Task is waiting to allocate a message
mbed_official 112:53ace74b190c 2077 if (isr != 0U) {
mbed_official 49:77c8e4604045 2078 rt_psq_enq (pmcb, (U32)pool);
mbed_official 49:77c8e4604045 2079 rt_psh_req ();
mbed_official 49:77c8e4604045 2080 } else {
mbed_official 49:77c8e4604045 2081 mem = rt_alloc_box(pool);
mbed_official 49:77c8e4604045 2082 if (mem != NULL) {
mbed_official 49:77c8e4604045 2083 ptcb = rt_get_first((P_XCB)pmcb);
mbed_official 49:77c8e4604045 2084 rt_ret_val(ptcb, (U32)mem);
mbed_official 49:77c8e4604045 2085 rt_rmv_dly(ptcb);
mbed_official 49:77c8e4604045 2086 rt_dispatch(ptcb);
mbed_official 49:77c8e4604045 2087 }
mbed_official 49:77c8e4604045 2088 }
mbed_official 49:77c8e4604045 2089 }
mbed_official 49:77c8e4604045 2090
mbed_official 49:77c8e4604045 2091 return osOK;
mbed_official 49:77c8e4604045 2092 }
mbed_official 49:77c8e4604045 2093
mbed_official 49:77c8e4604045 2094
mbed_official 49:77c8e4604045 2095 // Mail Queue Management Public API
mbed_official 49:77c8e4604045 2096
mbed_official 49:77c8e4604045 2097 /// Create and Initialize mail queue
mbed_official 112:53ace74b190c 2098 osMailQId osMailCreate (const osMailQDef_t *queue_def, osThreadId thread_id) {
mbed_official 112:53ace74b190c 2099 if (__get_IPSR() != 0U) {
mbed_official 112:53ace74b190c 2100 return NULL; // Not allowed in ISR
mbed_official 112:53ace74b190c 2101 }
mbed_official 112:53ace74b190c 2102 if (((__get_CONTROL() & 1U) == 0U) && (os_running == 0U)) {
mbed_official 49:77c8e4604045 2103 // Privileged and not running
mbed_official 49:77c8e4604045 2104 return svcMailCreate(queue_def, thread_id);
mbed_official 49:77c8e4604045 2105 } else {
mbed_official 49:77c8e4604045 2106 return __svcMailCreate(queue_def, thread_id);
mbed_official 49:77c8e4604045 2107 }
mbed_official 49:77c8e4604045 2108 }
mbed_official 49:77c8e4604045 2109
mbed_official 49:77c8e4604045 2110 /// Allocate a memory block from a mail
mbed_official 49:77c8e4604045 2111 void *osMailAlloc (osMailQId queue_id, uint32_t millisec) {
mbed_official 112:53ace74b190c 2112 if (__get_IPSR() != 0U) { // in ISR
mbed_official 112:53ace74b190c 2113 return sysMailAlloc(queue_id, millisec, 1U);
mbed_official 49:77c8e4604045 2114 } else { // in Thread
mbed_official 112:53ace74b190c 2115 return __sysMailAlloc(queue_id, millisec, 0U);
mbed_official 49:77c8e4604045 2116 }
mbed_official 49:77c8e4604045 2117 }
mbed_official 49:77c8e4604045 2118
mbed_official 49:77c8e4604045 2119 /// Allocate a memory block from a mail and set memory block to zero
mbed_official 49:77c8e4604045 2120 void *osMailCAlloc (osMailQId queue_id, uint32_t millisec) {
mbed_official 112:53ace74b190c 2121 void *pool;
mbed_official 112:53ace74b190c 2122 void *mem;
mbed_official 112:53ace74b190c 2123
mbed_official 112:53ace74b190c 2124 if (__get_IPSR() != 0U) { // in ISR
mbed_official 112:53ace74b190c 2125 mem = sysMailAlloc(queue_id, millisec, 1U);
mbed_official 49:77c8e4604045 2126 } else { // in Thread
mbed_official 112:53ace74b190c 2127 mem = __sysMailAlloc(queue_id, millisec, 0U);
mbed_official 49:77c8e4604045 2128 }
mbed_official 112:53ace74b190c 2129
mbed_official 112:53ace74b190c 2130 pool = *(((void **)queue_id) + 1);
mbed_official 112:53ace74b190c 2131
mbed_official 112:53ace74b190c 2132 rt_clr_box(pool, mem);
mbed_official 112:53ace74b190c 2133
mbed_official 112:53ace74b190c 2134 return mem;
mbed_official 49:77c8e4604045 2135 }
mbed_official 49:77c8e4604045 2136
mbed_official 49:77c8e4604045 2137 /// Free a memory block from a mail
mbed_official 49:77c8e4604045 2138 osStatus osMailFree (osMailQId queue_id, void *mail) {
mbed_official 112:53ace74b190c 2139 if (__get_IPSR() != 0U) { // in ISR
mbed_official 112:53ace74b190c 2140 return sysMailFree(queue_id, mail, 1U);
mbed_official 49:77c8e4604045 2141 } else { // in Thread
mbed_official 112:53ace74b190c 2142 return __sysMailFree(queue_id, mail, 0U);
mbed_official 49:77c8e4604045 2143 }
mbed_official 49:77c8e4604045 2144 }
mbed_official 49:77c8e4604045 2145
mbed_official 49:77c8e4604045 2146 /// Put a mail to a queue
mbed_official 49:77c8e4604045 2147 osStatus osMailPut (osMailQId queue_id, void *mail) {
mbed_official 112:53ace74b190c 2148 if (queue_id == NULL) {
mbed_official 112:53ace74b190c 2149 return osErrorParameter;
mbed_official 112:53ace74b190c 2150 }
mbed_official 112:53ace74b190c 2151 if (mail == NULL) {
mbed_official 112:53ace74b190c 2152 return osErrorValue;
mbed_official 112:53ace74b190c 2153 }
mbed_official 112:53ace74b190c 2154 return osMessagePut(*((void **)queue_id), (uint32_t)mail, 0U);
mbed_official 49:77c8e4604045 2155 }
mbed_official 49:77c8e4604045 2156
mbed_official 49:77c8e4604045 2157 /// Get a mail from a queue
mbed_official 49:77c8e4604045 2158 os_InRegs osEvent osMailGet (osMailQId queue_id, uint32_t millisec) {
mbed_official 49:77c8e4604045 2159 osEvent ret;
mbed_official 49:77c8e4604045 2160
mbed_official 49:77c8e4604045 2161 if (queue_id == NULL) {
mbed_official 49:77c8e4604045 2162 ret.status = osErrorParameter;
mbed_official 49:77c8e4604045 2163 return ret;
mbed_official 49:77c8e4604045 2164 }
mbed_official 49:77c8e4604045 2165
mbed_official 49:77c8e4604045 2166 ret = osMessageGet(*((void **)queue_id), millisec);
mbed_official 49:77c8e4604045 2167 if (ret.status == osEventMessage) ret.status = osEventMail;
mbed_official 49:77c8e4604045 2168
mbed_official 49:77c8e4604045 2169 return ret;
mbed_official 49:77c8e4604045 2170 }
mbed_official 112:53ace74b190c 2171
mbed_official 112:53ace74b190c 2172
mbed_official 112:53ace74b190c 2173 // ==== RTX Extensions ====
mbed_official 112:53ace74b190c 2174
mbed_official 112:53ace74b190c 2175 // Service Calls declarations
mbed_official 112:53ace74b190c 2176 SVC_0_1(rt_suspend, uint32_t, RET_uint32_t)
mbed_official 112:53ace74b190c 2177 SVC_1_0(rt_resume, void, uint32_t)
mbed_official 112:53ace74b190c 2178
mbed_official 112:53ace74b190c 2179
mbed_official 112:53ace74b190c 2180 // Public API
mbed_official 112:53ace74b190c 2181
mbed_official 112:53ace74b190c 2182 /// Suspends the OS task scheduler
mbed_official 112:53ace74b190c 2183 uint32_t os_suspend (void) {
mbed_official 112:53ace74b190c 2184 return __rt_suspend();
mbed_official 112:53ace74b190c 2185 }
mbed_official 112:53ace74b190c 2186
mbed_official 112:53ace74b190c 2187 /// Resumes the OS task scheduler
mbed_official 112:53ace74b190c 2188 void os_resume (uint32_t sleep_time) {
mbed_official 112:53ace74b190c 2189 __rt_resume(sleep_time);
mbed_official 112:53ace74b190c 2190 }