Line data    Source code

       1            0 : /* atomic operations */
       2              : 
       3              : /*
       4              :  * Copyright (c) 1997-2015, Wind River Systems, Inc.
       5              :  * Copyright (c) 2023 Nordic Semiconductor ASA
       6              :  *
       7              :  * SPDX-License-Identifier: Apache-2.0
       8              :  */
       9              : 
      10              : #ifndef ZEPHYR_INCLUDE_SYS_ATOMIC_BUILTIN_H_
      11              : #define ZEPHYR_INCLUDE_SYS_ATOMIC_BUILTIN_H_
      12              : 
      13              : #include <stdbool.h>
      14              : #include <stddef.h>
      15              : #include <zephyr/sys/atomic_types.h>
      16              : 
      17              : #ifdef __cplusplus
      18              : extern "C" {
      19              : #endif
      20              : 
      21              : /* Included from <atomic.h> */
      22              : 
      23            0 : static inline bool atomic_cas(atomic_t *target, atomic_val_t old_value,
      24              :                           atomic_val_t new_value)
      25              : {
      26              :         return __atomic_compare_exchange_n(target, &old_value, new_value,
      27              :                                            0, __ATOMIC_SEQ_CST,
      28              :                                            __ATOMIC_SEQ_CST);
      29              : }
      30              : 
      31            0 : static inline bool atomic_ptr_cas(atomic_ptr_t *target, atomic_ptr_val_t old_value,
      32              :                                   atomic_ptr_val_t new_value)
      33              : {
      34              :         return __atomic_compare_exchange_n(target, &old_value, new_value,
      35              :                                            0, __ATOMIC_SEQ_CST,
      36              :                                            __ATOMIC_SEQ_CST);
      37              : }
      38              : 
      39            0 : static inline atomic_val_t atomic_add(atomic_t *target, atomic_val_t value)
      40              : {
      41              :         return __atomic_fetch_add(target, value, __ATOMIC_SEQ_CST);
      42              : }
      43              : 
      44            0 : static inline atomic_val_t atomic_sub(atomic_t *target, atomic_val_t value)
      45              : {
      46              :         return __atomic_fetch_sub(target, value, __ATOMIC_SEQ_CST);
      47              : }
      48              : 
      49            0 : static inline atomic_val_t atomic_inc(atomic_t *target)
      50              : {
      51              :         return atomic_add(target, 1);
      52              : }
      53              : 
      54            0 : static inline atomic_val_t atomic_dec(atomic_t *target)
      55              : {
      56              :         return atomic_sub(target, 1);
      57              : }
      58              : 
      59            0 : static inline atomic_val_t atomic_get(const atomic_t *target)
      60              : {
      61              :         return __atomic_load_n(target, __ATOMIC_SEQ_CST);
      62              : }
      63              : 
      64            0 : static inline atomic_ptr_val_t atomic_ptr_get(const atomic_ptr_t *target)
      65              : {
      66              :         return __atomic_load_n(target, __ATOMIC_SEQ_CST);
      67              : }
      68              : 
      69            0 : static inline atomic_val_t atomic_set(atomic_t *target, atomic_val_t value)
      70              : {
      71              :         /* This builtin, as described by Intel, is not a traditional
      72              :          * test-and-set operation, but rather an atomic exchange operation. It
      73              :          * writes value into *ptr, and returns the previous contents of *ptr.
      74              :          */
      75              :         return __atomic_exchange_n(target, value, __ATOMIC_SEQ_CST);
      76              : }
      77              : 
      78            0 : static inline atomic_ptr_val_t atomic_ptr_set(atomic_ptr_t *target, atomic_ptr_val_t value)
      79              : {
      80              :         return __atomic_exchange_n(target, value, __ATOMIC_SEQ_CST);
      81              : }
      82              : 
      83            0 : static inline atomic_val_t atomic_clear(atomic_t *target)
      84              : {
      85              :         return atomic_set(target, 0);
      86              : }
      87              : 
      88            0 : static inline atomic_ptr_val_t atomic_ptr_clear(atomic_ptr_t *target)
      89              : {
      90              :         return atomic_ptr_set(target, NULL);
      91              : }
      92              : 
      93            0 : static inline atomic_val_t atomic_or(atomic_t *target, atomic_val_t value)
      94              : {
      95              :         return __atomic_fetch_or(target, value, __ATOMIC_SEQ_CST);
      96              : }
      97              : 
      98            0 : static inline atomic_val_t atomic_xor(atomic_t *target, atomic_val_t value)
      99              : {
     100              :         return __atomic_fetch_xor(target, value, __ATOMIC_SEQ_CST);
     101              : }
     102              : 
     103            0 : static inline atomic_val_t atomic_and(atomic_t *target, atomic_val_t value)
     104              : {
     105              :         return __atomic_fetch_and(target, value, __ATOMIC_SEQ_CST);
     106              : }
     107              : 
     108            0 : static inline atomic_val_t atomic_nand(atomic_t *target, atomic_val_t value)
     109              : {
     110              :         return __atomic_fetch_nand(target, value, __ATOMIC_SEQ_CST);
     111              : }
     112              : 
     113              : #ifdef __cplusplus
     114              : }
     115              : #endif
     116              : 
     117              : #endif /* ZEPHYR_INCLUDE_SYS_ATOMIC_BUILTIN_H_ */