• (GCC)STM32基础详解之全局资源的使用

    注：测试硬件非STM32(而是nRF52832)，但是笔者认为这在所有Cortex-M3、M4单片机上是一样的情况，所以标题为了与之前系列相同而取了STM32。

    1.问题描述

    全局资源在此处通常指一个全局变量，它可以是一个全局的buf、结构体变量、指针等等。如果你的代码里只有一个while，没有使用任何RTOS或中断，那是不会存在资源竟争问题的，因为不存在打断操作，代码执行流程永远是从上到下顺序执行。(MCU上好像没有听说有使用乱序执行技术)

    之前也有遇到过相似的问题，不过没有完整记录，此次遇到就正好完整记录一下。

    代码很简单，笔者在main函数中while(1)中使用发送函数发送一段数据，使用3个变量：

    发送次数累加，发送成功一次累加，发送失败一次累加

    正常我们很容易知道：

    发送次数 = 发送成功次数 + 发送失败次数

    然后笔者使用一个定时器，每隔1秒在定时器中断回调中打印发送的次数、成功的次数、失败的次数，然后清0，但是会出现：

    发送次数 != 发送成功次数+发送失败次数

    而且相差很大。

    2.原因分析

    变量声明：

    main的循环中有：

    很简单明了的代码，调用 nrf_esb_write_payload  这个发送函数，要么成功，要么失败，所以无论如何总有：

    writeCount = writeSuccess + writeFailed

    然后笔者使用了一个定时器，定时时间为1秒，也就是1秒触发一次中断回调，然后在中断回调里对这三个变量打印，定时器配置不再赘述，直接给中断回调函数内容：

    可以看到，打印完这三个变量后，就把3个变量置0，重新开始累计。

    实际代码运行打印：

    可以看到出现异常的时候，一共发送了628886次，却失败了1253521次或是发送了1257731次，却成功2025次，失败626839次，剩余那60多万次哪去了？

    其实仔细观察，可以发现，异常的时候，均是那个异常变量没有清0，其值是此次值和上次的值相加！ 

    难道是清0那行代码没有生效？

    不可能，首先只要正常打印了，它后面清0的代码也必定执行，而且如果没有清0，必定3个变量都不会清0，而且即使是在定时器中断回调执行时被其他中断抢占，在其他中断结束后，也会继续执行定时器中断。

    遇事不决，查看汇编。

    上图是中断中如何令writeCount这个变量清0。 

    上图中已经描述了变量累加以及清0是如何用汇编实现的。看到这你应该明白：

    writeCount++;

    这个看似只有一行的代码，实际用了3行汇编去实现。这就有个问题，假如在执行：

    LDR            R3, [R6] 

    这行代码后，被定时器中断打断，转而去执行了中断处理函数会发生什么？

    查看变量地址我们知道：

    writeCount这个变量其实地址是0x2000 0248，一开始

    R6 =  writeCount

    其实就是R6 = 0x2000 0248，然后

    R3 = *R6

    即R3 = *(0x2000 0248)，假如此时已经发送了60 0000次了，那也就是R3 = 60 0000，这个时候定时器定时时间到了，跑去执行定时器中断处理函数，再假如此时发送成功了2000次，失败了59 8000次，那么定时器中断处理函数中会打印：

    发送60 0000次，成功2000次，失败59 8000次

    然后把writeCount、writeSuccess、writeFailed都清0了，也就是此时你再去取0x2000 0248这个地址上的值，已经变成0了，但是，在处理完定时器中断回调后，我们继续执行的是：

    ADDS           R3, #1

    STR            R3, [R6]

    因为在中断前我们已经取过 0x2000 0248这个地址上的值到R3中了，即使再回来继续执行，我们用的之前保存到R3里面的值，此时R3还是之前读进去的60 0000，继续执行则变成：

    R3 = 60 0000+1

    *(0x2000 0248) = 60 0001

    此时我们把刚清0的writeCount赋值成了60 0001！这导致我们在中断中的清0操作失效了！

    3.解决办法

    3.1原子操作

    由上一节分析我们知道了为啥清0会失败，就是因为

    writeCount++

    这个操作是分为3步执行的！假如这个操作必须完整的执行，不能拆分，那也就不存在上面的异常情况。不能拆分的操作，我们称作原子操作，在nRF的SDK中有提供原子操作的库函数，它们被放在 nrf_atomic.c中，如果你使用的是GCC编译器，那么这些函数稍作修改也同样可以运用到STM32中，因为它们都是cortex-M4内核的MCU，本质是一样的。该文件中主要函数是：

    这个函数中主要是汇编操作：

    可以看到主要使用的是ldrex和strex独占访问指令(也有叫排他访问)，感兴趣的可以自行搜索。

    STM提供的原子操作：

    https://github.com/STMicroelectronics/STM32CubeF4/blob/4aba24d78fef03d797a82b258f37dbc84728bbb5/Drivers/CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h#L230

    这里我们使用nRF的SDK中提供的原子操作函数试一下：

    经过长时间测试发现不再会出现上述问题，相关打印如下：

    但是可以看到，因为原子操作需要更多的指令，效率有所下降。 

    3.2互斥量

    互斥量常常用于多线程中访问共享资源的情况，在nRF的SDK中互斥量的实现在nrf_mtx.h中。

    其实互斥量很简单，同一时刻，互斥量只能被一个地方拥有(这个地方可以是中断处理回调或者RTOS中的任务循环函数)。当我们在任何需要修改一个共享资源的时候，先去获取一个互斥量，如果可以获取到，证明这个资源没有在被使用，如果没有获取到证明有其他修改它的地方已经获取到了。其实互斥量的实现也使用了原子操作：

    可以看到每个从互斥量操作都使用了__DMB() 这个内联汇编函数 ，它的函数原型是：

    在Cortex-M3权威指南里有：

    这个和Cortex-M的3级流水线设计息息相关，感兴趣的自行搜索。

    最后main函数类似这样：

    但是注意，如果是在RTOS中使用互斥锁很方便，但是在中断中使用互斥锁就不太好，原因如下：

    1.中断等待与死锁

    在你刚开始学习中断的时候肯定有人告诉你，中断中不能延时，这里如果是一个任务使用while等待一点问题没有，但是因为不清楚while到底会等待多久，所以这里肯定不可以使用while等待。

    其次，while在这里会造成死锁，因为假如我们在main函数中已经获取到了互斥锁，这时候被定时器中断回调打断，定时器中断就算一直等待其他地方互斥锁释放也是徒劳，因为中断回调没有执行完，永远不会转头回去继续执行main函数中的while，而main中的while那次循环执行不完，又永远不会释放互斥锁，这就陷入了死循环，也可以叫死锁。 

    2.跳过

    在这个例子中，因为中断每次进入都有一秒的间隔，这里如果获取不到就跳过，那么每次都会出现2秒才打印1次的现象，所以这里跳过也不太合理。当然，如果这是在一个会一直循环的任务里影响就很小了。

    综上所述，在中断中使用互斥量不是一个好的选择，但是如果是在RTOS的任务中会有效的多。 

    3.3关中断

    如果你使用过RTOS，你应该知道临界区，它就是保护资源的一种方式，临界区最简单的做法就是关闭中断。上述原子操作的解决思路是把操作压缩到一个不可分割的整体，是从自身出发，而关中断会让定时器这个可能打断我们操作的异常给kill掉，这是从外部出发。

    nRF的SDK中有提供打开和关闭中断的方法，在cmsis_gcc.h中有：

    而我们需要做的只是：

    这样，在操作这几个全局变量的时候就不会被定时器中断所打断，打印如下：

    可以看到，虽然有所损失，但是比原子操作耗时短得多，几乎和没有关中断差不太多。但是这儿有个问题，在笔者这个例子中关闭中断和再次开启中断中间只有一个发送函数，如果你所需要保护的区域有很多操作甚至是等待时，长时间的关闭中断很有可能带来其他问题。我们需要尽可能的把临界区弄的短一点：

    最好是只在最关键的操作使用中断的开关。当然这势必造成效率下降：

    很显然，在这个例子中，只在开头和结尾开关中断好像比分割成3次更加合理。

    3.4屏蔽中断

    Cortex-M内核很贴心的提供了可屏蔽优先级寄存器BASEPRI：

    关于这个寄存器，更为详细的资料可以参考宋岩译的那本《Cortex-M3权威指南》。

    而在cmsis_gcc.h中也有设置这个寄存器的函数：

    另一个带MAX的是：

    所以我们只需要这样操作：

    和上一个关中断差不多，但是这里笔者配置的定时器中断优先级是6，而其他中断优先级都在4以上，所以这里我设置为屏蔽4及以下的中断(优先级号越大，优先级越低) 。这里如果是STM32，则需要根据所选的中断分组再判断是设置高4位的哪几位，因为STM32分抢占优先级和响应优先级，这个设置只对抢占优先级有效。而nRF只有0~7八个优先级，不分抢占和响应，所以直接设置即可，至于为什么是高4位，因为芯片设计如此。

    这里同样解决了上述问题，打印如下：

    可以看到设置此寄存器比只开关中断要耗时的多。如果我们按照上一节思路，把开关屏蔽中断分为3次，应该更加耗时：

    打印如下：

    可以看到和关闭全局中断差不多。 

    4.总结

    在使用一个共享的全局资源时，多个地方修改这个资源可能会引发问题。可以使用原子操作、互斥量、关闭中断或者屏蔽中断解决。它们各有利弊：

    1.原子操作并不一定是一条指令，而可能是很多条指令，只是通过独占访问等实现，所以原子操作可能更加耗时，对于时间敏感的地方需要衡量是否会影响功能。但是好处是它不对其他中断有影响，比如这个例子中的定时器中断，它的响应并不会被延迟。

    2.关闭所有中断简单粗暴，但在实际项目中，可能使用了很多中断，并不是所有中断都可以随意关闭，有些中断被关闭可能引发一些问题。虽然关闭期间触发的中断会在中断打开后继续执行，但是这无疑加大了中断延迟，对于一些对响应速度要求很高的中断来说，这无疑是灭顶之灾。所以关闭中断使用次数越少越好，关闭时间越短越好。

    3.屏蔽部分中断解决了一部分关闭所有中断的问题，我们可以只屏蔽那些优先级没那么高的中断，但是加重了对不同中断优先级分配的复杂度。像此例子中nRF只有0~7八种中断优先级，而STM32中屏蔽中断只能对抢占优先级生效，所以实际设置时要根据4种主次优先级分配的位数设置。

    4.互斥量在中断中使用会引起很多问题，应该在RTOS的任务中使用。

    附：

    nrf_atomic.c

    1. /**
    2.  * Copyright (c) 2018 - 2019, Nordic Semiconductor ASA
    3.  *
    4.  * All rights reserved.
    5.  *
    6.  * Redistribution and use in source and binary forms, with or without modification,
    7.  * are permitted provided that the following conditions are met:
    8.  *
    9.  * 1. Redistributions of source code must retain the above copyright notice, this
    10.  *    list of conditions and the following disclaimer.
    11.  *
    12.  * 2. Redistributions in binary form, except as embedded into a Nordic
    13.  *    Semiconductor ASA integrated circuit in a product or a software update for
    14.  *    such product, must reproduce the above copyright notice, this list of
    15.  *    conditions and the following disclaimer in the documentation and/or other
    16.  *    materials provided with the distribution.
    17.  *
    18.  * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
    19.  *    contributors may be used to endorse or promote products derived from this
    20.  *    software without specific prior written permission.
    21.  *
    22.  * 4. This software, with or without modification, must only be used with a
    23.  *    Nordic Semiconductor ASA integrated circuit.
    24.  *
    25.  * 5. Any software provided in binary form under this license must not be reverse
    26.  *    engineered, decompiled, modified and/or disassembled.
    27.  *
    28.  * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
    29.  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    30.  * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
    31.  * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
    32.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    33.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
    34.  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    35.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    36.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
    37.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    38.  *
    39.  */
    40. #include "nrf_atomic.h"
    41.  
    42. #ifndef NRF_ATOMIC_USE_BUILD_IN
    43. #if (defined(__GNUC__) && defined(WIN32))
    44.     #define NRF_ATOMIC_USE_BUILD_IN 1
    45. #else
    46.     #define NRF_ATOMIC_USE_BUILD_IN 0
    47. #endif
    48. #endif // NRF_ATOMIC_USE_BUILD_IN
    49.  
    50. #if ((__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U))
    51. #define STREX_LDREX_PRESENT
    52. #else
    53. #include "app_util_platform.h"
    54. #endif
    55.  
    56.  
    57. #if (NRF_ATOMIC_USE_BUILD_IN == 0) && defined(STREX_LDREX_PRESENT)
    58. #include "nrf_atomic_internal.h"
    59. #endif
    60.  
    61. uint32_t nrf_atomic_u32_fetch_store(nrf_atomic_u32_t * p_data, uint32_t value)
    62. {
    63. #if NRF_ATOMIC_USE_BUILD_IN
    64.     return __atomic_exchange_n(p_data, value, __ATOMIC_SEQ_CST);
    65.  
    66. #elif defined(STREX_LDREX_PRESENT)
    67.     uint32_t old_val;
    68.     uint32_t new_val;
    69.     NRF_ATOMIC_OP(mov, old_val, new_val, p_data, value);
    70.  
    71.     UNUSED_PARAMETER(old_val);
    72.     UNUSED_PARAMETER(new_val);
    73.     return old_val;
    74. #else
    75.     CRITICAL_REGION_ENTER();
    76.     uint32_t old_val = *p_data;
    77.     *p_data = value;
    78.     CRITICAL_REGION_EXIT();
    79.     return old_val;
    80. #endif //NRF_ATOMIC_USE_BUILD_IN
    81. }
    82.  
    83. uint32_t nrf_atomic_u32_store(nrf_atomic_u32_t * p_data, uint32_t value)
    84. {
    85. #if NRF_ATOMIC_USE_BUILD_IN
    86.     __atomic_store_n(p_data, value, __ATOMIC_SEQ_CST);
    87.     return value;
    88. #elif defined(STREX_LDREX_PRESENT)
    89.     uint32_t old_val;
    90.     uint32_t new_val;
    91.  
    92.     NRF_ATOMIC_OP(mov, old_val, new_val, p_data, value);
    93.  
    94.     UNUSED_PARAMETER(old_val);
    95.     UNUSED_PARAMETER(new_val);
    96.     return new_val;
    97. #else
    98.     CRITICAL_REGION_ENTER();
    99.     *p_data = value;
    100.     CRITICAL_REGION_EXIT();
    101.     return value;
    102. #endif //NRF_ATOMIC_USE_BUILD_IN
    103. }
    104.  
    105. uint32_t nrf_atomic_u32_fetch_or(nrf_atomic_u32_t * p_data, uint32_t value)
    106. {
    107. #if NRF_ATOMIC_USE_BUILD_IN
    108.     return __atomic_fetch_or(p_data, value, __ATOMIC_SEQ_CST);
    109. #elif defined(STREX_LDREX_PRESENT)
    110.     uint32_t old_val;
    111.     uint32_t new_val;
    112.  
    113.     NRF_ATOMIC_OP(orr, old_val, new_val, p_data, value);
    114.     UNUSED_PARAMETER(old_val);
    115.     UNUSED_PARAMETER(new_val);
    116.     return old_val;
    117. #else
    118.     CRITICAL_REGION_ENTER();
    119.     uint32_t old_val = *p_data;
    120.     *p_data |= value;
    121.     CRITICAL_REGION_EXIT();
    122.     return old_val;
    123. #endif //NRF_ATOMIC_USE_BUILD_IN
    124. }
    125.  
    126. uint32_t nrf_atomic_u32_or(nrf_atomic_u32_t * p_data, uint32_t value)
    127. {
    128. #if NRF_ATOMIC_USE_BUILD_IN
    129.     return __atomic_or_fetch(p_data, value, __ATOMIC_SEQ_CST);
    130. #elif defined(STREX_LDREX_PRESENT)
    131.     uint32_t old_val;
    132.     uint32_t new_val;
    133.  
    134.     NRF_ATOMIC_OP(orr, old_val, new_val, p_data, value);
    135.     UNUSED_PARAMETER(old_val);
    136.     UNUSED_PARAMETER(new_val);
    137.     return new_val;
    138. #else
    139.     CRITICAL_REGION_ENTER();
    140.     *p_data |= value;
    141.     uint32_t new_value = *p_data;
    142.     CRITICAL_REGION_EXIT();
    143.     return new_value;
    144. #endif //NRF_ATOMIC_USE_BUILD_IN
    145. }
    146.  
    147. uint32_t nrf_atomic_u32_fetch_and(nrf_atomic_u32_t * p_data, uint32_t value)
    148. {
    149. #if NRF_ATOMIC_USE_BUILD_IN
    150.     return __atomic_fetch_and(p_data, value, __ATOMIC_SEQ_CST);
    151. #elif defined(STREX_LDREX_PRESENT)
    152.     uint32_t old_val;
    153.     uint32_t new_val;
    154.  
    155.     NRF_ATOMIC_OP(and, old_val, new_val, p_data, value);
    156.     UNUSED_PARAMETER(old_val);
    157.     UNUSED_PARAMETER(new_val);
    158.     return old_val;
    159. #else
    160.     CRITICAL_REGION_ENTER();
    161.     uint32_t old_val = *p_data;
    162.     *p_data &= value;
    163.     CRITICAL_REGION_EXIT();
    164.     return old_val;
    165. #endif //NRF_ATOMIC_USE_BUILD_IN
    166. }
    167.  
    168. uint32_t nrf_atomic_u32_and(nrf_atomic_u32_t * p_data, uint32_t value)
    169. {
    170. #if NRF_ATOMIC_USE_BUILD_IN
    171.     return __atomic_and_fetch(p_data, value, __ATOMIC_SEQ_CST);
    172. #elif defined(STREX_LDREX_PRESENT)
    173.     uint32_t old_val;
    174.     uint32_t new_val;
    175.  
    176.     NRF_ATOMIC_OP(and, old_val, new_val, p_data, value);
    177.     UNUSED_PARAMETER(old_val);
    178.     UNUSED_PARAMETER(new_val);
    179.     return new_val;
    180. #else
    181.     CRITICAL_REGION_ENTER();
    182.     *p_data &= value;
    183.     uint32_t new_value = *p_data;
    184.     CRITICAL_REGION_EXIT();
    185.     return new_value;
    186. #endif //NRF_ATOMIC_USE_BUILD_IN
    187. }
    188.  
    189. uint32_t nrf_atomic_u32_fetch_xor(nrf_atomic_u32_t * p_data, uint32_t value)
    190. {
    191. #if NRF_ATOMIC_USE_BUILD_IN
    192.     return __atomic_fetch_xor(p_data, value, __ATOMIC_SEQ_CST);
    193. #elif defined(STREX_LDREX_PRESENT)
    194.     uint32_t old_val;
    195.     uint32_t new_val;
    196.  
    197.     NRF_ATOMIC_OP(eor, old_val, new_val, p_data, value);
    198.     UNUSED_PARAMETER(old_val);
    199.     UNUSED_PARAMETER(new_val);
    200.     return old_val;
    201. #else
    202.     CRITICAL_REGION_ENTER();
    203.     uint32_t old_val = *p_data;
    204.     *p_data ^= value;
    205.     CRITICAL_REGION_EXIT();
    206.     return old_val;
    207. #endif //NRF_ATOMIC_USE_BUILD_IN
    208. }
    209.  
    210. uint32_t nrf_atomic_u32_xor(nrf_atomic_u32_t * p_data, uint32_t value)
    211. {
    212. #if NRF_ATOMIC_USE_BUILD_IN
    213.     return __atomic_xor_fetch(p_data, value, __ATOMIC_SEQ_CST);
    214. #elif defined(STREX_LDREX_PRESENT)
    215.     uint32_t old_val;
    216.     uint32_t new_val;
    217.  
    218.     NRF_ATOMIC_OP(eor, old_val, new_val, p_data, value);
    219.     UNUSED_PARAMETER(old_val);
    220.     UNUSED_PARAMETER(new_val);
    221.     return new_val;
    222. #else
    223.     CRITICAL_REGION_ENTER();
    224.     *p_data ^= value;
    225.     uint32_t new_value = *p_data;
    226.     CRITICAL_REGION_EXIT();
    227.     return new_value;
    228. #endif //NRF_ATOMIC_USE_BUILD_IN
    229. }
    230.  
    231. uint32_t nrf_atomic_u32_fetch_add(nrf_atomic_u32_t * p_data, uint32_t value)
    232. {
    233. #if NRF_ATOMIC_USE_BUILD_IN
    234.     return __atomic_fetch_add(p_data, value, __ATOMIC_SEQ_CST);
    235. #elif defined(STREX_LDREX_PRESENT)
    236.     uint32_t old_val;
    237.     uint32_t new_val;
    238.  
    239.     NRF_ATOMIC_OP(add, old_val, new_val, p_data, value);
    240.     UNUSED_PARAMETER(old_val);
    241.     UNUSED_PARAMETER(new_val);
    242.     return old_val;
    243. #else
    244.     CRITICAL_REGION_ENTER();
    245.     uint32_t old_val = *p_data;
    246.     *p_data += value;
    247.     CRITICAL_REGION_EXIT();
    248.     return old_val;
    249. #endif //NRF_ATOMIC_USE_BUILD_IN
    250. }
    251.  
    252. uint32_t nrf_atomic_u32_add(nrf_atomic_u32_t * p_data, uint32_t value)
    253. {
    254. #if NRF_ATOMIC_USE_BUILD_IN
    255.     return __atomic_add_fetch(p_data, value, __ATOMIC_SEQ_CST);
    256. #elif defined(STREX_LDREX_PRESENT)
    257.     uint32_t old_val;
    258.     uint32_t new_val;
    259.  
    260.     NRF_ATOMIC_OP(add, old_val, new_val, p_data, value);
    261.     UNUSED_PARAMETER(old_val);
    262.     UNUSED_PARAMETER(new_val);
    263.     return new_val;
    264. #else
    265.     CRITICAL_REGION_ENTER();
    266.     *p_data += value;
    267.     uint32_t new_value = *p_data;
    268.     CRITICAL_REGION_EXIT();
    269.     return new_value;
    270. #endif //NRF_ATOMIC_USE_BUILD_IN
    271. }
    272.  
    273. uint32_t nrf_atomic_u32_fetch_sub(nrf_atomic_u32_t * p_data, uint32_t value)
    274. {
    275. #if NRF_ATOMIC_USE_BUILD_IN
    276.     return __atomic_fetch_sub(p_data, value, __ATOMIC_SEQ_CST);
    277. #elif defined(STREX_LDREX_PRESENT)
    278.     uint32_t old_val;
    279.     uint32_t new_val;
    280.  
    281.     NRF_ATOMIC_OP(sub, old_val, new_val, p_data, value);
    282.     UNUSED_PARAMETER(old_val);
    283.     UNUSED_PARAMETER(new_val);
    284.     return old_val;
    285. #else
    286.     CRITICAL_REGION_ENTER();
    287.     uint32_t old_val = *p_data;
    288.     *p_data -= value;
    289.     CRITICAL_REGION_EXIT();
    290.     return old_val;
    291. #endif //NRF_ATOMIC_USE_BUILD_IN
    292. }
    293.  
    294. uint32_t nrf_atomic_u32_sub(nrf_atomic_u32_t * p_data, uint32_t value)
    295. {
    296. #if NRF_ATOMIC_USE_BUILD_IN
    297.     return __atomic_sub_fetch(p_data, value, __ATOMIC_SEQ_CST);
    298. #elif defined(STREX_LDREX_PRESENT)
    299.     uint32_t old_val;
    300.     uint32_t new_val;
    301.  
    302.     NRF_ATOMIC_OP(sub, old_val, new_val, p_data, value);
    303.     UNUSED_PARAMETER(old_val);
    304.     UNUSED_PARAMETER(new_val);
    305.     return new_val;
    306. #else
    307.     CRITICAL_REGION_ENTER();
    308.     *p_data -= value;
    309.     uint32_t new_value = *p_data;
    310.     CRITICAL_REGION_EXIT();
    311.     return new_value;
    312. #endif //NRF_ATOMIC_USE_BUILD_IN
    313. }
    314.  
    315. bool nrf_atomic_u32_cmp_exch(nrf_atomic_u32_t * p_data,
    316.                                            uint32_t *         p_expected,
    317.                                            uint32_t           desired)
    318. {
    319. #if NRF_ATOMIC_USE_BUILD_IN
    320.     return __atomic_compare_exchange(p_data,
    321.                                      p_expected,
    322.                                      &desired,
    323.                                      1,
    324.                                      __ATOMIC_SEQ_CST,
    325.                                      __ATOMIC_SEQ_CST);
    326. #elif defined(STREX_LDREX_PRESENT)
    327.     return nrf_atomic_internal_cmp_exch(p_data, p_expected, desired);
    328. #else
    329.     bool ret;
    330.     CRITICAL_REGION_ENTER();
    331.     if (*p_data == *p_expected)
    332.     {
    333.         *p_data = desired;
    334.         ret = true;
    335.     }
    336.     else
    337.     {
    338.         *p_expected = *p_data;
    339.         ret = false;
    340.     }
    341.     CRITICAL_REGION_EXIT();
    342.     return ret;
    343. #endif
    344. }
    345.  
    346. uint32_t nrf_atomic_u32_fetch_sub_hs(nrf_atomic_u32_t * p_data, uint32_t value)
    347. {
    348. #if NRF_ATOMIC_USE_BUILD_IN
    349.     uint32_t expected = *p_data;
    350.     uint32_t new_val;
    351.     bool     success;
    352.  
    353.     do
    354.     {
    355.         if (expected >= value)
    356.         {
    357.             new_val = expected - value;
    358.         }
    359.         else
    360.         {
    361.             new_val = expected;
    362.         }
    363.         success = __atomic_compare_exchange(p_data,
    364.                                             &expected,
    365.                                             &new_val,
    366.                                             1,
    367.                                             __ATOMIC_SEQ_CST,
    368.                                             __ATOMIC_SEQ_CST);
    369.     } while(!success);
    370.     return expected;
    371. #elif defined(STREX_LDREX_PRESENT)
    372.     uint32_t old_val;
    373.     uint32_t new_val;
    374.  
    375.     NRF_ATOMIC_OP(sub_hs, old_val, new_val, p_data, value);
    376.     UNUSED_PARAMETER(old_val);
    377.     UNUSED_PARAMETER(new_val);
    378.     return old_val;
    379. #else
    380.     CRITICAL_REGION_ENTER();
    381.     uint32_t old_val = *p_data;
    382.     *p_data -= value;
    383.     CRITICAL_REGION_EXIT();
    384.     return old_val;
    385. #endif //NRF_ATOMIC_USE_BUILD_IN
    386. }
    387.  
    388. uint32_t nrf_atomic_u32_sub_hs(nrf_atomic_u32_t * p_data, uint32_t value)
    389. {
    390. #if NRF_ATOMIC_USE_BUILD_IN
    391.     uint32_t expected = *p_data;
    392.     uint32_t new_val;
    393.     bool     success;
    394.  
    395.     do
    396.     {
    397.         if (expected >= value)
    398.         {
    399.             new_val = expected - value;
    400.         }
    401.         else
    402.         {
    403.             new_val = expected;
    404.         }
    405.         success = __atomic_compare_exchange(p_data,
    406.                                             &expected,
    407.                                             &new_val,
    408.                                             1,
    409.                                             __ATOMIC_SEQ_CST,
    410.                                             __ATOMIC_SEQ_CST);
    411.     } while(!success);
    412.     return new_val;
    413. #elif defined(STREX_LDREX_PRESENT)
    414.     uint32_t old_val;
    415.     uint32_t new_val;
    416.  
    417.     NRF_ATOMIC_OP(sub_hs, old_val, new_val, p_data, value);
    418.     UNUSED_PARAMETER(old_val);
    419.     UNUSED_PARAMETER(new_val);
    420.     return new_val;
    421. #else
    422.     CRITICAL_REGION_ENTER();
    423.     *p_data -= value;
    424.     uint32_t new_value = *p_data;
    425.     CRITICAL_REGION_EXIT();
    426.     return new_value;
    427. #endif //NRF_ATOMIC_USE_BUILD_IN
    428. }
    429.  
    430. uint32_t nrf_atomic_flag_set_fetch(nrf_atomic_flag_t * p_data)
    431. {
    432.     return nrf_atomic_u32_fetch_or(p_data, 1);
    433. }
    434.  
    435. uint32_t nrf_atomic_flag_set(nrf_atomic_flag_t * p_data)
    436. {
    437.     return nrf_atomic_u32_or(p_data, 1);
    438. }
    439.  
    440. uint32_t nrf_atomic_flag_clear_fetch(nrf_atomic_flag_t * p_data)
    441. {
    442.     return nrf_atomic_u32_fetch_and(p_data, 0);
    443. }
    444.  
    445. uint32_t nrf_atomic_flag_clear(nrf_atomic_flag_t * p_data)
    446. {
    447.     return nrf_atomic_u32_and(p_data, 0);
    448. }
    449.

    nrf_atomic_internal.h

    1. /**
    2.  * Copyright (c) 2016 - 2019, Nordic Semiconductor ASA
    3.  *
    4.  * All rights reserved.
    5.  *
    6.  * Redistribution and use in source and binary forms, with or without modification,
    7.  * are permitted provided that the following conditions are met:
    8.  *
    9.  * 1. Redistributions of source code must retain the above copyright notice, this
    10.  *    list of conditions and the following disclaimer.
    11.  *
    12.  * 2. Redistributions in binary form, except as embedded into a Nordic
    13.  *    Semiconductor ASA integrated circuit in a product or a software update for
    14.  *    such product, must reproduce the above copyright notice, this list of
    15.  *    conditions and the following disclaimer in the documentation and/or other
    16.  *    materials provided with the distribution.
    17.  *
    18.  * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
    19.  *    contributors may be used to endorse or promote products derived from this
    20.  *    software without specific prior written permission.
    21.  *
    22.  * 4. This software, with or without modification, must only be used with a
    23.  *    Nordic Semiconductor ASA integrated circuit.
    24.  *
    25.  * 5. Any software provided in binary form under this license must not be reverse
    26.  *    engineered, decompiled, modified and/or disassembled.
    27.  *
    28.  * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
    29.  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    30.  * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
    31.  * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
    32.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    33.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
    34.  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    35.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    36.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
    37.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    38.  *
    39.  */
    40. #ifndef NRF_ATOMIC_INTERNAL_H__
    41. #define NRF_ATOMIC_INTERNAL_H__
    42.  
    43. #include "sdk_common.h"
    44. #include 
    45. #include 
    46.  
    47. #ifdef __cplusplus
    48. extern "C" {
    49. #endif
    50.  
    51. /**
    52.  *
    53.  * @defgroup nrf_atomic_internal Atomic operations internals
    54.  * @ingroup nrf_atomic
    55.  * @{
    56.  *
    57.  */
    58.  
    59. /* Only Cortex M cores > 3 support LDREX/STREX instructions*/
    60. #if ((__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U)) == 0
    61. #error "Unsupported core version"
    62. #endif
    63.  
    64. #if defined ( __CC_ARM )
    65. static __asm uint32_t nrf_atomic_internal_mov(nrf_atomic_u32_t * p_ptr,
    66.                                               uint32_t value,
    67.                                               uint32_t * p_new)
    68. {
    69.     /* The base standard provides for passing arguments in core registers (r0-r3) and on the stack.
    70.      * Registers r4 and r5 have to be saved on stack. Note that only even number of register push are
    71.      * allowed. This is a requirement of the Procedure Call Standard for the ARM Architecture [AAPCS].
    72.      * */
    73.     push  {r4, r5}
    74.     mov   r4, r0
    75.  
    76. loop_mov
    77.     ldrex r0, [r4]
    78.     mov   r5, r1
    79.     strex r3, r5, [r4]
    80.     cmp   r3, #0
    81.     bne   loop_mov
    82.  
    83.     str   r5, [r2]
    84.     pop   {r4, r5}
    85.     bx    lr
    86. }
    87.  
    88.  
    89. static __asm uint32_t nrf_atomic_internal_orr(nrf_atomic_u32_t * p_ptr,
    90.                                               uint32_t value,
    91.                                               uint32_t * p_new)
    92. {
    93.     push  {r4, r5}
    94.     mov   r4, r0
    95.  
    96. loop_orr
    97.     ldrex r0, [r4]
    98.     orr   r5, r0, r1
    99.     strex r3, r5, [r4]
    100.     cmp   r3, #0
    101.     bne   loop_orr
    102.  
    103.     str   r5, [r2]
    104.     pop   {r4, r5}
    105.     bx    lr
    106. }
    107.  
    108. static __asm uint32_t nrf_atomic_internal_and(nrf_atomic_u32_t * p_ptr,
    109.                                               uint32_t value,
    110.                                               uint32_t * p_new)
    111. {
    112.     push  {r4, r5}
    113.     mov   r4, r0
    114.  
    115. loop_and
    116.     ldrex r0, [r4]
    117.     and   r5, r0, r1
    118.     strex r3, r5, [r4]
    119.     cmp   r3, #0
    120.     bne   loop_and
    121.  
    122.     str   r5, [r2]
    123.     pop   {r4, r5}
    124.     bx    lr
    125. }
    126.  
    127. static __asm uint32_t nrf_atomic_internal_eor(nrf_atomic_u32_t * p_ptr,
    128.                                               uint32_t value,
    129.                                               uint32_t * p_new)
    130. {
    131.     push  {r4, r5}
    132.     mov   r4, r0
    133.  
    134. loop_eor
    135.     ldrex r0, [r4]
    136.     eor   r5, r0, r1
    137.     strex r3, r5, [r4]
    138.     cmp   r3, #0
    139.     bne   loop_eor
    140.  
    141.     str   r5, [r2]
    142.     pop   {r4, r5}
    143.     bx    lr
    144. }
    145.  
    146. static __asm uint32_t nrf_atomic_internal_add(nrf_atomic_u32_t * p_ptr,
    147.                                               uint32_t value,
    148.                                               uint32_t * p_new)
    149. {
    150.     push  {r4, r5}
    151.     mov   r4, r0
    152.  
    153. loop_add
    154.     ldrex r0, [r4]
    155.     add   r5, r0, r1
    156.     strex r3, r5, [r4]
    157.     cmp   r3, #0
    158.     bne   loop_add
    159.  
    160.     str   r5, [r2]
    161.     pop   {r4, r5}
    162.     bx    lr
    163. }
    164.  
    165. static __asm uint32_t nrf_atomic_internal_sub(nrf_atomic_u32_t * p_ptr,
    166.                                               uint32_t value,
    167.                                               uint32_t * p_new)
    168. {
    169.     push  {r4, r5}
    170.     mov   r4, r0
    171.  
    172. loop_sub
    173.     ldrex r0, [r4]
    174.     sub   r5, r0, r1
    175.     strex r3, r5, [r4]
    176.     cmp   r3, #0
    177.     bne   loop_sub
    178.  
    179.     str   r5, [r2]
    180.     pop   {r4, r5}
    181.     bx    lr
    182. }
    183.  
    184. static __asm bool nrf_atomic_internal_cmp_exch(nrf_atomic_u32_t * p_data,
    185.                                                uint32_t *         p_expected,
    186.                                                uint32_t           value)
    187. {
    188. #define RET_REG  r0
    189. #define P_EXPC   r1
    190. #define VALUE    r2
    191. #define STR_RES  r3
    192. #define P_DATA   r4
    193. #define EXPC_VAL r5
    194. #define ACT_VAL  r6
    195.  
    196.     push {r4-r6}
    197.     mov  P_DATA, r0
    198.     mov  RET_REG, #0
    199.  
    200. loop_cmp_exch
    201.     ldrex   ACT_VAL, [P_DATA]
    202.     ldr     EXPC_VAL, [P_EXPC]
    203.     cmp     ACT_VAL, EXPC_VAL
    204.     ittee   eq
    205.     strexeq STR_RES, VALUE, [P_DATA]
    206.     moveq   RET_REG, #1
    207.     strexne STR_RES, ACT_VAL, [P_DATA]
    208.     strne   ACT_VAL, [P_EXPC]
    209.     cmp     STR_RES, #0
    210.     itt     ne
    211.     movne   RET_REG, #0
    212.     bne     loop_cmp_exch
    213.  
    214.     pop {r4-r6}
    215.     bx    lr
    216.  
    217. #undef RET_REG
    218. #undef P_EXPC
    219. #undef VALUE
    220. #undef STR_RES
    221. #undef P_DATA
    222. #undef EXPC_VAL
    223. #undef ACT_VAL
    224. }
    225.  
    226. static __asm uint32_t nrf_atomic_internal_sub_hs(nrf_atomic_u32_t * p_ptr,
    227.                                                  uint32_t value,
    228.                                                  uint32_t * p_new)
    229. {
    230.     push  {r4, r5}
    231.     mov   r4, r0
    232.  
    233. loop_sub_ge
    234.     ldrex r0, [r4]
    235.     cmp   r0, r1
    236.     ite   hs
    237.     subhs r5, r0, r1
    238.     movlo r5, r0
    239.     strex r3, r5, [r4]
    240.     cmp   r3, #0
    241.     bne   loop_sub_ge
    242.  
    243.     str   r5, [r2]
    244.     pop   {r4, r5}
    245.     bx    lr
    246. }
    247.  
    248.  
    249. #define NRF_ATOMIC_OP(asm_op, old_val, new_val, ptr, value)          \
    250.         old_val = nrf_atomic_internal_##asm_op(ptr, value, &new_val)
    251.  
    252. #elif defined ( __ICCARM__ ) || defined ( __GNUC__ )
    253.  
    254. /**
    255.  * @brief Atomic operation generic macro
    256.  * @param[in] asm_op operation: mov, orr, and, eor, add, sub
    257.  * @param[out] old_val atomic object output (uint32_t), value before operation
    258.  * @param[out] new_val atomic object output (uint32_t), value after operation
    259.  * @param[in] value atomic operation operand
    260.  * */
    261. #define NRF_ATOMIC_OP(asm_op, old_val, new_val, ptr, value)                 \
    262. {                                                                           \
    263.     uint32_t str_res;                                                       \
    264.             __ASM volatile(                                                 \
    265.     "1:     ldrex   %["#old_val"], [%["#ptr"]]\n"                           \
    266.     NRF_ATOMIC_OP_##asm_op(new_val, old_val, value)                         \
    267.     "       strex   %[str_res], %["#new_val"], [%["#ptr"]]\n"               \
    268.     "       teq     %[str_res], #0\n"                                       \
    269.     "       bne.n     1b"                                                   \
    270.             :                                                               \
    271.         [old_val]"=&r" (old_val),                                           \
    272.         [new_val]"=&r" (new_val),                                           \
    273.         [str_res]"=&r" (str_res)                                            \
    274.             :                                                               \
    275.         [ptr]"r" (ptr),                                                     \
    276.         [value]"r" (value)                                                  \
    277.             : "cc");                                                        \
    278.     UNUSED_PARAMETER(str_res);                                              \
    279. }
    280.  
    281. #define NRF_ATOMIC_OP_mov(new_val, old_val, value) "mov %["#new_val"], %["#value"]\n"
    282. #define NRF_ATOMIC_OP_orr(new_val, old_val, value) "orr %["#new_val"], %["#old_val"], %["#value"]\n"
    283. #define NRF_ATOMIC_OP_and(new_val, old_val, value) "and %["#new_val"], %["#old_val"], %["#value"]\n"
    284. #define NRF_ATOMIC_OP_eor(new_val, old_val, value) "eor %["#new_val"], %["#old_val"], %["#value"]\n"
    285. #define NRF_ATOMIC_OP_add(new_val, old_val, value) "add %["#new_val"], %["#old_val"], %["#value"]\n"
    286. #define NRF_ATOMIC_OP_sub(new_val, old_val, value) "sub %["#new_val"], %["#old_val"], %["#value"]\n"
    287. #define NRF_ATOMIC_OP_sub_hs(new_val, old_val, value)                                              \
    288.     "cmp %["#old_val"], %["#value"]\n "                                                            \
    289.     "ite hs\n"                                                                                     \
    290.     "subhs %["#new_val"], %["#old_val"], %["#value"]\n"                                            \
    291.     "movlo %["#new_val"], %["#old_val"]\n"
    292.  
    293. static inline bool nrf_atomic_internal_cmp_exch(nrf_atomic_u32_t * p_data,
    294.                                                 uint32_t *         p_expected,
    295.                                                 uint32_t           value)
    296. {
    297.     bool res = false;
    298.     uint32_t str_res = 0;
    299.     uint32_t act_val = 0;
    300.     uint32_t exp_val = 0;
    301.     UNUSED_VARIABLE(str_res);
    302.     UNUSED_VARIABLE(act_val);
    303.     UNUSED_VARIABLE(exp_val);
    304.     __ASM volatile(
    305.     "1:     ldrex   %[act_val], [%[ptr]]\n"
    306.     "       ldr     %[exp_val], [%[expc]]\n"
    307.     "       cmp     %[act_val], %[exp_val]\n"
    308.     "       ittee   eq\n"
    309.     "       strexeq %[str_res], %[value], [%[ptr]]\n"
    310.     "       moveq   %[res], #1\n"
    311.     "       strexne %[str_res], %[act_val], [%[ptr]]\n"
    312.     "       strne   %[act_val], [%[expc]]\n"
    313.     "       cmp     %[str_res], #0\n"
    314.     "       itt     ne\n"
    315.     "       movne   %[res], #0\n"
    316.     "       bne.n     1b"
    317.             :
    318.         [res]     "=&r" (res),
    319.         [exp_val] "=&r" (exp_val),
    320.         [act_val]    "=&r" (act_val),
    321.         [str_res] "=&r" (str_res)
    322.             :
    323.         "0" (res),
    324.         "1" (exp_val),
    325.         "2" (act_val),
    326.         [expc]  "r" (p_expected),
    327.         [ptr]   "r" (p_data),
    328.         [value] "r" (value)
    329.             : "cc");
    330.     return res;
    331. }
    332.  
    333. #else
    334. #error "Unsupported compiler"
    335. #endif
    336.  
    337. #ifdef __cplusplus
    338. }
    339. #endif
    340.  
    341. #endif /* NRF_ATOMIC_INTERNAL_H__ */
    342.  
    343. /** @} */

    nrf_mtx.h

    1. /**
    2.  * Copyright (c) 2015 - 2019, Nordic Semiconductor ASA
    3.  *
    4.  * All rights reserved.
    5.  *
    6.  * Redistribution and use in source and binary forms, with or without modification,
    7.  * are permitted provided that the following conditions are met:
    8.  *
    9.  * 1. Redistributions of source code must retain the above copyright notice, this
    10.  *    list of conditions and the following disclaimer.
    11.  *
    12.  * 2. Redistributions in binary form, except as embedded into a Nordic
    13.  *    Semiconductor ASA integrated circuit in a product or a software update for
    14.  *    such product, must reproduce the above copyright notice, this list of
    15.  *    conditions and the following disclaimer in the documentation and/or other
    16.  *    materials provided with the distribution.
    17.  *
    18.  * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
    19.  *    contributors may be used to endorse or promote products derived from this
    20.  *    software without specific prior written permission.
    21.  *
    22.  * 4. This software, with or without modification, must only be used with a
    23.  *    Nordic Semiconductor ASA integrated circuit.
    24.  *
    25.  * 5. Any software provided in binary form under this license must not be reverse
    26.  *    engineered, decompiled, modified and/or disassembled.
    27.  *
    28.  * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
    29.  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    30.  * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
    31.  * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
    32.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    33.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
    34.  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    35.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    36.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
    37.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    38.  *
    39.  */
    40. /** @file
    41.  * @defgroup nrf_mtx nRF Mutex
    42.  * @{
    43.  * @ingroup app_common
    44.  * @brief Mutex used for protecting resources.
    45.  *
    46.  * This module provides a mutex that can be used to ensure only one context may enter a critical
    47.  * section holding the lock.
    48.  */
    49. #ifndef NRF_MTX_H__
    50. #define NRF_MTX_H__
    51.  
    52. #include 
    53. #include 
    54. #include "nrf.h"
    55. #include "nrf_atomic.h"
    56. #include "nrf_assert.h"
    57.  
    58. #define NRF_MTX_LOCKED      1
    59. #define NRF_MTX_UNLOCKED    0
    60.  
    61. /**
    62.  * @brief Mutex data type.
    63.  *
    64.  * All fields in this struct are internal, and should never be modified outside of the nrf_mtx_*
    65.  * functions.
    66.  */
    67. typedef nrf_atomic_u32_t nrf_mtx_t;
    68.  
    69. /**
    70.  * @brief Initialize mutex.
    71.  *
    72.  * This function _must_ be called before nrf_mtx_trylock() and nrf_mtx_unlock() functions.
    73.  *
    74.  * @param[in, out] p_mtx The mutex to be initialized.
    75.  */
    76. __STATIC_INLINE void nrf_mtx_init(nrf_mtx_t * p_mtx);
    77.  
    78.  
    79. /**
    80.  * @brief Destroy mutex.
    81.  *
    82.  * This function can be used in abort scenarios or when the mutex is no longer to be used.
    83.  *
    84.  * @param[in] p_mtx The mutex to be destroy.
    85.  */
    86. __STATIC_INLINE void nrf_mtx_destroy(nrf_mtx_t * p_mtx);
    87.  
    88. /**
    89.  * @brief Try to lock a mutex.
    90.  *
    91.  * If the mutex is already held by another context, this function will return immediately.
    92.  *
    93.  * @param[in, out] p_mtx The mutex to be locked.
    94.  * @return true if lock was acquired, false if not
    95.  */
    96. __STATIC_INLINE bool nrf_mtx_trylock(nrf_mtx_t * p_mtx);
    97.  
    98. /**
    99.  * @brief Unlock a mutex.
    100.  *
    101.  * This function _must_ only be called when holding the lock. Unlocking a mutex which you do not
    102.  * hold will give undefined behavior.
    103.  *
    104.  * @note Unlock must happen from the same context as the one used to lock the mutex.
    105.  *
    106.  * @param[in, out] p_mtx The mutex to be unlocked.
    107.  */
    108. __STATIC_INLINE void nrf_mtx_unlock(nrf_mtx_t * p_mtx);
    109.  
    110. #ifndef SUPPRESS_INLINE_IMPLEMENTATION
    111.  
    112. __STATIC_INLINE void nrf_mtx_init(nrf_mtx_t * p_mtx)
    113. {
    114.     ASSERT(p_mtx  != NULL);
    115.  
    116.     *p_mtx = NRF_MTX_UNLOCKED;
    117.     __DMB();
    118. }
    119.  
    120. __STATIC_INLINE void nrf_mtx_destroy(nrf_mtx_t * p_mtx)
    121. {
    122.     ASSERT(p_mtx  != NULL);
    123.  
    124.     // Add memory barrier to ensure that any memory operations protected by the mutex complete
    125.     // before the mutex is destroyed.
    126.     __DMB();
    127.  
    128.     *p_mtx = NRF_MTX_UNLOCKED;
    129. }
    130.  
    131. __STATIC_INLINE bool nrf_mtx_trylock(nrf_mtx_t * p_mtx)
    132. {
    133.     ASSERT(p_mtx  != NULL);
    134.  
    135.     uint32_t old_val = nrf_atomic_u32_fetch_store(p_mtx, NRF_MTX_LOCKED);
    136.  
    137.     // Add memory barrier to ensure that the mutex is locked before any memory operations protected
    138.     // by the mutex are started.
    139.     __DMB();
    140.  
    141.     return (old_val == NRF_MTX_UNLOCKED);
    142. }
    143.  
    144. __STATIC_INLINE void nrf_mtx_unlock(nrf_mtx_t * p_mtx)
    145. {
    146.     ASSERT(p_mtx  != NULL);
    147.     ASSERT(*p_mtx == NRF_MTX_LOCKED);
    148.  
    149.     // Add memory barrier to ensure that any memory operations protected by the mutex complete
    150.     // before the mutex is unlocked.
    151.     __DMB();
    152.  
    153.     *p_mtx = NRF_MTX_UNLOCKED;
    154. }
    155.  
    156. #endif //SUPPRESS_INLINE_IMPLEMENTATION
    157.  
    158. #endif // NRF_MTX_H__
    159. /** @} */

    nordic_common.h

    1. /**
    2.  * Copyright (c) 2008 - 2019, Nordic Semiconductor ASA
    3.  *
    4.  * All rights reserved.
    5.  *
    6.  * Redistribution and use in source and binary forms, with or without modification,
    7.  * are permitted provided that the following conditions are met:
    8.  *
    9.  * 1. Redistributions of source code must retain the above copyright notice, this
    10.  *    list of conditions and the following disclaimer.
    11.  *
    12.  * 2. Redistributions in binary form, except as embedded into a Nordic
    13.  *    Semiconductor ASA integrated circuit in a product or a software update for
    14.  *    such product, must reproduce the above copyright notice, this list of
    15.  *    conditions and the following disclaimer in the documentation and/or other
    16.  *    materials provided with the distribution.
    17.  *
    18.  * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
    19.  *    contributors may be used to endorse or promote products derived from this
    20.  *    software without specific prior written permission.
    21.  *
    22.  * 4. This software, with or without modification, must only be used with a
    23.  *    Nordic Semiconductor ASA integrated circuit.
    24.  *
    25.  * 5. Any software provided in binary form under this license must not be reverse
    26.  *    engineered, decompiled, modified and/or disassembled.
    27.  *
    28.  * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
    29.  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    30.  * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
    31.  * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
    32.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    33.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
    34.  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    35.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    36.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
    37.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    38.  *
    39.  */
    40. /** @file
    41.  * @brief Common defines and macros for firmware developed by Nordic Semiconductor.
    42.  */
    43.  
    44. #ifndef NORDIC_COMMON_H__
    45. #define NORDIC_COMMON_H__
    46.  
    47. #ifdef __cplusplus
    48. extern "C" {
    49. #endif
    50.  
    51. /**
    52.  * @brief Check if selected module is enabled
    53.  *
    54.  * This is save function for driver enable checking.
    55.  * Correct from Lint point of view (not using default of undefined value).
    56.  *
    57.  * Usage:
    58.  * @code
    59.    #if NRF_MODULE_ENABLED(UART)
    60.    ...
    61.    #endif
    62.  * @endcode
    63.  *
    64.  * @param module The module name.
    65.  *
    66.  * @retval 1 The macro _ENABLE is defined and is non-zero.
    67.  * @retval 0 The macro _ENABLE is not defined or it equals zero.
    68.  *
    69.  * @note
    70.  * This macro intentionally does not implement second expansion level.
    71.  * The name of the module to be checked has to be given directly as a parameter.
    72.  * And given parameter would be connected with @c _ENABLED postfix directly
    73.  * without evaluating its value.
    74.  */
    75. //lint -emacro(491,NRF_MODULE_ENABLED) // Suppers warning 491 "non-standard use of 'defined' preprocessor operator"
    76. #ifdef NRF_MODULE_ENABLE_ALL
    77. #warning "Do not use NRF_MODULE_ENABLE_ALL for real builds."
    78. #define NRF_MODULE_ENABLED(module) 1
    79. #else
    80. #define NRF_MODULE_ENABLED(module) \
    81.     ((defined(module ## _ENABLED) && (module ## _ENABLED)) ? 1 : 0)
    82. #endif
    83. /** The upper 8 bits of a 32 bit value */
    84. //lint -emacro(572,MSB_32) // Suppress warning 572 "Excessive shift value"
    85. #define MSB_32(a) (((a) & 0xFF000000) >> 24)
    86. /** The lower 8 bits (of a 32 bit value) */
    87. #define LSB_32(a) ((a) & 0x000000FF)
    88.  
    89. /** The upper 8 bits of a 16 bit value */
    90. //lint -emacro(572,MSB_16) // Suppress warning 572 "Excessive shift value"
    91. #define MSB_16(a) (((a) & 0xFF00) >> 8)
    92. /** The lower 8 bits (of a 16 bit value) */
    93. #define LSB_16(a) ((a) & 0x00FF)
    94.  
    95. /** Leaves the minimum of the two 32-bit arguments */
    96. /*lint -emacro(506, MIN) */ /* Suppress "Constant value Boolean */
    97. #define MIN(a, b) ((a) < (b) ? (a) : (b))
    98. /** Leaves the maximum of the two 32-bit arguments */
    99. /*lint -emacro(506, MAX) */ /* Suppress "Constant value Boolean */
    100. #define MAX(a, b) ((a) < (b) ? (b) : (a))
    101.  
    102. /**@brief Concatenates two parameters.
    103.  *
    104.  * It realizes two level expansion to make it sure that all the parameters
    105.  * are actually expanded before gluing them together.
    106.  *
    107.  * @param p1 First parameter to concatenating
    108.  * @param p2 Second parameter to concatenating
    109.  *
    110.  * @return Two parameters glued together.
    111.  *         They have to create correct C mnemonic in other case
    112.  *         preprocessor error would be generated.
    113.  *
    114.  * @sa CONCAT_3
    115.  */
    116. #define CONCAT_2(p1, p2)      CONCAT_2_(p1, p2)
    117. /** Auxiliary macro used by @ref CONCAT_2 */
    118. #define CONCAT_2_(p1, p2)     p1##p2
    119.  
    120. /**@brief Concatenates three parameters.
    121.  *
    122.  * It realizes two level expansion to make it sure that all the parameters
    123.  * are actually expanded before gluing them together.
    124.  *
    125.  * @param p1 First parameter to concatenating
    126.  * @param p2 Second parameter to concatenating
    127.  * @param p3 Third parameter to concatenating
    128.  *
    129.  * @return Three parameters glued together.
    130.  *         They have to create correct C mnemonic in other case
    131.  *         preprocessor error would be generated.
    132.  *
    133.  * @sa CONCAT_2
    134.  */
    135. #define CONCAT_3(p1, p2, p3)  CONCAT_3_(p1, p2, p3)
    136. /** Auxiliary macro used by @ref CONCAT_3 */
    137. #define CONCAT_3_(p1, p2, p3) p1##p2##p3
    138.  
    139. #define STRINGIFY_(val) #val
    140. /** Converts a macro argument into a character constant.
    141.  */
    142. #define STRINGIFY(val)  STRINGIFY_(val)
    143.  
    144. /** Counts number of elements inside the array
    145.  */
    146. #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
    147.  
    148. /**@brief Set a bit in the uint32 word.
    149.  *
    150.  * @param[in] W  Word whose bit is being set.
    151.  * @param[in] B  Bit number in the word to be set.
    152.  */
    153. #define SET_BIT(W, B)  ((W) |= (uint32_t)(1U << (B)))
    154.  
    155.  
    156. /**@brief Clears a bit in the uint32 word.
    157.  *
    158.  * @param[in] W   Word whose bit is to be cleared.
    159.  * @param[in] B   Bit number in the word to be cleared.
    160.  */
    161. #define CLR_BIT(W, B) ((W) &= (~(uint32_t)(1U << (B))))
    162.  
    163.  
    164. /**@brief Checks if a bit is set.
    165.  *
    166.  * @param[in] W   Word whose bit is to be checked.
    167.  * @param[in] B   Bit number in the word to be checked.
    168.  *
    169.  * @retval 1 if bit is set.
    170.  * @retval 0 if bit is not set.
    171.  */
    172. #define IS_SET(W, B) (((W) >> (B)) & 1)
    173.  
    174. #define BIT_0 0x01 /**< The value of bit 0 */
    175. #define BIT_1 0x02 /**< The value of bit 1 */
    176. #define BIT_2 0x04 /**< The value of bit 2 */
    177. #define BIT_3 0x08 /**< The value of bit 3 */
    178. #define BIT_4 0x10 /**< The value of bit 4 */
    179. #define BIT_5 0x20 /**< The value of bit 5 */
    180. #define BIT_6 0x40 /**< The value of bit 6 */
    181. #define BIT_7 0x80 /**< The value of bit 7 */
    182. #define BIT_8 0x0100 /**< The value of bit 8 */
    183. #define BIT_9 0x0200 /**< The value of bit 9 */
    184. #define BIT_10 0x0400 /**< The value of bit 10 */
    185. #define BIT_11 0x0800 /**< The value of bit 11 */
    186. #define BIT_12 0x1000 /**< The value of bit 12 */
    187. #define BIT_13 0x2000 /**< The value of bit 13 */
    188. #define BIT_14 0x4000 /**< The value of bit 14 */
    189. #define BIT_15 0x8000 /**< The value of bit 15 */
    190. #define BIT_16 0x00010000 /**< The value of bit 16 */
    191. #define BIT_17 0x00020000 /**< The value of bit 17 */
    192. #define BIT_18 0x00040000 /**< The value of bit 18 */
    193. #define BIT_19 0x00080000 /**< The value of bit 19 */
    194. #define BIT_20 0x00100000 /**< The value of bit 20 */
    195. #define BIT_21 0x00200000 /**< The value of bit 21 */
    196. #define BIT_22 0x00400000 /**< The value of bit 22 */
    197. #define BIT_23 0x00800000 /**< The value of bit 23 */
    198. #define BIT_24 0x01000000 /**< The value of bit 24 */
    199. #define BIT_25 0x02000000 /**< The value of bit 25 */
    200. #define BIT_26 0x04000000 /**< The value of bit 26 */
    201. #define BIT_27 0x08000000 /**< The value of bit 27 */
    202. #define BIT_28 0x10000000 /**< The value of bit 28 */
    203. #define BIT_29 0x20000000 /**< The value of bit 29 */
    204. #define BIT_30 0x40000000 /**< The value of bit 30 */
    205. #define BIT_31 0x80000000 /**< The value of bit 31 */
    206.  
    207. #define UNUSED_VARIABLE(X)  ((void)(X))
    208. #define UNUSED_PARAMETER(X) UNUSED_VARIABLE(X)
    209. #define UNUSED_RETURN_VALUE(X) UNUSED_VARIABLE(X)
    210.  
    211. #ifdef __cplusplus
    212. }
    213. #endif
    214.  
    215. #endif // NORDIC_COMMON_H__

  • 相关阅读:
    Serverless安全揭秘：架构、风险与防护措施
    ABAP:调用HTTP接口详解
    图的存储方式
    c++虚拟继承那些事
    从零开始 Spring Boot 17：MyBatis Plus 续
    持续交付探索与实践（三）：指标度量体系搭建
    申请专利的好处！这份清单告诉你，为什么要申请专利？
    ubuntu 安装postgresql，增加VECTOR向量数据库插件 踏坑详细流程
    联想曝新型UEFI漏洞，影响70款数百万台笔记本电脑
    Otsu阈值分割详解
  • 原文地址：https://blog.csdn.net/qwe5959798/article/details/126176408