atomic.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997-2015, Wind River Systems, Inc.
 * Copyright (c) 2021 Intel Corporation
 * Copyright (c) 2023 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_SYS_ATOMIC_H_
#define ZEPHYR_INCLUDE_SYS_ATOMIC_H_
 
#include <stdbool.h>
#include <zephyr/toolchain.h>
#include <stddef.h>
 
#include <zephyr/sys/atomic_types.h> /* IWYU pragma: export */
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Low-level primitives come in several styles: */
 
#if defined(CONFIG_ATOMIC_OPERATIONS_C)
/* Generic-but-slow implementation based on kernel locking and syscalls */
#include <zephyr/sys/atomic_c.h>
#elif defined(CONFIG_ATOMIC_OPERATIONS_ARCH)
/* Some architectures need their own implementation */
# ifdef CONFIG_XTENSA
/* Not all Xtensa toolchains support GCC-style atomic intrinsics */
# include <zephyr/arch/xtensa/atomic_xtensa.h>
# elif defined(CONFIG_ARC)
/* MWDT ignores the memory-order argument of the atomic builtins */
# include <zephyr/arch/arc/atomic_arc.h>
# else
/* Other arch specific implementation */
# include <zephyr/sys/atomic_arch.h>
# endif /* CONFIG_XTENSA */
#elif defined(CONFIG_ATOMIC_OPERATIONS_BUILTIN)
/* Default.  See this file for the Doxygen reference: */
#include <zephyr/sys/atomic_builtin.h>
#else
#error "CONFIG_ATOMIC_OPERATIONS_* not defined"
#endif
 
/* Portable higher-level utilities: */


#define ATOMIC_INIT(i) (i)

#define ATOMIC_PTR_INIT(p) (p)

 
#define ATOMIC_BITS            (sizeof(atomic_val_t) * BITS_PER_BYTE)
#define ATOMIC_MASK(bit) BIT((unsigned long)(bit) & (ATOMIC_BITS - 1U))
#define ATOMIC_ELEM(addr, bit) ((addr) + ((bit) / ATOMIC_BITS))


#define ATOMIC_BITMAP_SIZE(num_bits) (ROUND_UP(num_bits, ATOMIC_BITS) / ATOMIC_BITS)

#define ATOMIC_DEFINE(name, num_bits) \
        atomic_t name[ATOMIC_BITMAP_SIZE(num_bits)]

static inline bool atomic_test_bit(const atomic_t *target, int bit)
{
        atomic_val_t val = atomic_get(ATOMIC_ELEM(target, bit));
 
        return (1 & (val >> (bit & (ATOMIC_BITS - 1)))) != 0;
}

static inline bool atomic_test_and_clear_bit(atomic_t *target, int bit)
{
        atomic_val_t mask = ATOMIC_MASK(bit);
        atomic_val_t old;
 
        old = atomic_and(ATOMIC_ELEM(target, bit), ~mask);
 
        return (old & mask) != 0;
}

static inline bool atomic_test_and_set_bit(atomic_t *target, int bit)
{
        atomic_val_t mask = ATOMIC_MASK(bit);
        atomic_val_t old;
 
        old = atomic_or(ATOMIC_ELEM(target, bit), mask);
 
        return (old & mask) != 0;
}

static inline bool atomic_test_and_set_bit_to(atomic_t *target, int bit, bool val)
{
        atomic_val_t mask = ATOMIC_MASK(bit);
 
        if (val) {
                return (atomic_or(ATOMIC_ELEM(target, bit), mask) & mask) == 0;
        }
 
        return (atomic_and(ATOMIC_ELEM(target, bit), ~mask) & mask) != 0;
}

static inline void atomic_clear_bit(atomic_t *target, int bit)
{
        atomic_val_t mask = ATOMIC_MASK(bit);
 
        (void)atomic_and(ATOMIC_ELEM(target, bit), ~mask);
}

static inline void atomic_set_bit(atomic_t *target, int bit)
{
        atomic_val_t mask = ATOMIC_MASK(bit);
 
        (void)atomic_or(ATOMIC_ELEM(target, bit), mask);
}

static inline void atomic_set_bit_to(atomic_t *target, int bit, bool val)
{
        atomic_val_t mask = ATOMIC_MASK(bit);
 
        if (val) {
                (void)atomic_or(ATOMIC_ELEM(target, bit), mask);
        } else {
                (void)atomic_and(ATOMIC_ELEM(target, bit), ~mask);
        }
}

bool atomic_cas(atomic_t *target, atomic_val_t old_value, atomic_val_t new_value);

bool atomic_ptr_cas(atomic_ptr_t *target, atomic_ptr_val_t old_value,
                    atomic_ptr_val_t new_value);

atomic_val_t atomic_add(atomic_t *target, atomic_val_t value);

atomic_val_t atomic_sub(atomic_t *target, atomic_val_t value);

atomic_val_t atomic_inc(atomic_t *target);

atomic_val_t atomic_dec(atomic_t *target);

atomic_val_t atomic_get(const atomic_t *target);

atomic_ptr_val_t atomic_ptr_get(const atomic_ptr_t *target);

atomic_val_t atomic_set(atomic_t *target, atomic_val_t value);

atomic_ptr_val_t atomic_ptr_set(atomic_ptr_t *target, atomic_ptr_val_t value);

atomic_val_t atomic_clear(atomic_t *target);

atomic_ptr_val_t atomic_ptr_clear(atomic_ptr_t *target);

atomic_val_t atomic_or(atomic_t *target, atomic_val_t value);

atomic_val_t atomic_xor(atomic_t *target, atomic_val_t value);

atomic_val_t atomic_and(atomic_t *target, atomic_val_t value);

atomic_val_t atomic_nand(atomic_t *target, atomic_val_t value);

 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* ZEPHYR_INCLUDE_SYS_ATOMIC_H_ */