1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
/*
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "os_mutex.h"
#include "os_util.h"
/**
* @brief Create and initialize a mutex object
* @note A mutex can only be locked by a single thread at any given time.
* @param[in] mutex Pointer to the mutex object
* @retval OS_Status, OS_OK on success
*/
OS_Status OS_MutexCreate(OS_Mutex_t *mutex)
{
OS_HANDLE_ASSERT(!OS_MutexIsValid(mutex), mutex->handle);
mutex->handle = rt_mutex_create("os_mtx", RT_IPC_FLAG_PRIO);
OS_DBG("%s(), handle %p\n", __func__, mutex->handle);
if (mutex->handle == NULL) {
OS_ERR("err %"OS_HANDLE_F"\n", mutex->handle);
return OS_FAIL;
}
return OS_OK;
}
/**
* @brief Delete the mutex object
* @param[in] mutex Pointer to the mutex object
* @retval OS_Status, OS_OK on success
*/
OS_Status OS_MutexDelete(OS_Mutex_t *mutex)
{
rt_err_t ret;
OS_HANDLE_ASSERT(OS_MutexIsValid(mutex), mutex->handle);
ret = rt_mutex_delete(mutex->handle);
if (ret != RT_EOK) {
OS_ERR("err %"OS_BASETYPE_F"\n", ret);
return OS_FAIL;
}
OS_MutexSetInvalid(mutex);
return OS_OK;
}
/**
* @brief Lock the mutex object
* @note A mutex can only be locked by a single thread at any given time. If
* the mutex is already locked, the caller will be blocked for the
* specified time duration.
* @param[in] mutex Pointer to the mutex object
* @param[in] waitMS The maximum amount of time (in millisecond) the thread
* should remain in the blocked state to wait for the mutex
* to become unlocked.
* OS_WAIT_FOREVER for waiting forever, zero for no waiting.
* @retval OS_Status, OS_OK on success
*/
OS_Status OS_MutexLock(OS_Mutex_t *mutex, OS_Time_t waitMS)
{
rt_err_t ret;
OS_HANDLE_ASSERT(OS_MutexIsValid(mutex), mutex->handle);
ret = rt_mutex_take(mutex->handle, OS_CalcWaitTicks(waitMS));
if (ret != RT_EOK) {
OS_DBG("%s() fail @ %d, %"OS_TIME_F" ms\n", __func__, __LINE__, (unsigned int)waitMS);
return OS_FAIL;
}
return OS_OK;
}
/**
* @brief Unlock the mutex object previously locked using OS_MutexLock()
* @note The mutex should be unlocked from the same thread context from which
* it was locked.
* @param[in] mutex Pointer to the mutex object
* @retval OS_Status, OS_OK on success
*/
OS_Status OS_MutexUnlock(OS_Mutex_t *mutex)
{
rt_err_t ret;
OS_HANDLE_ASSERT(OS_MutexIsValid(mutex), mutex->handle);
ret = rt_mutex_release(mutex->handle);
if (ret != RT_EOK) {
OS_DBG("%s() fail @ %d\n", __func__, __LINE__);
return OS_FAIL;
}
return OS_OK;
}
|
