mbed-rtos - Official mbed Real Time Operating System based on…

Users » mbed_official » Code » mbed-rtos

Official mbed Real Time Operating System based on the RTX implementation of the CMSIS-RTOS API open standard.

Dependents: denki-yohou_b TestY201 Network-RTOS NTPClient_HelloWorld ... more

Deprecated

This is the mbed 2 rtos library. mbed OS 5 integrates the mbed library with mbed-rtos. With this, we have provided thread safety for all mbed APIs. If you'd like to learn about using mbed OS 5, please see the docs.

rtx/TARGET_CORTEX_A/rt_CMSIS.c@121:3da5f554d8bf, 2016-09-01 (annotated)

Committer:: <>
Date:: Thu Sep 01 15:13:42 2016 +0100
Revision:: 121:3da5f554d8bf
Parent:: 117:4c105b8d7cae
Child:: 123:58563e6cba1e

RTOS rev121



Compatible with the mbed library v125



Changes:

- K64F: Revert to hardcoded stack pointer in RTX.

- Adding NCS36510 support.

- Add MAX32620 target support.

- Fix implicit declaration of function 'atexit'.

Who changed what in which revision?

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