mirror of
https://github.com/apache/nuttx.git
synced 2026-08-25 15:37:23 +00:00
2f46ced5c7
Split the atomic implementation into three files: - arch_atomic.h: Shared macros (STORE, LOAD, etc.) using atomic_lock()/ atomic_unlock() abstraction - arch_atomic_irq.c: 32-bit atomic functions using IRQ disable (conditional on CONFIG_LIBC_ATOMIC_IRQ via Make.defs) - arch_atomic64.c: 64-bit atomic functions using spinlock (always compiled, multi-core safe). The __atomic_* functions are always provided (GCC runtime helpers), while nx_atomic_* functions are conditional on !CONFIG_LIBC_ATOMIC_TOOLCHAIN. Signed-off-by: zhangyu117 <zhangyu117@xiaomi.com>
320 lines
19 KiB
C
320 lines
19 KiB
C
/****************************************************************************
|
|
* libs/libc/machine/arch_atomic.h
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef __LIBS_LIBC_MACHINE_ARCH_ATOMIC_H
|
|
#define __LIBS_LIBC_MACHINE_ARCH_ATOMIC_H
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <nuttx/irq.h>
|
|
#include <nuttx/macro.h>
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
#define STORE(fn, n, type) \
|
|
\
|
|
void weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value, int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
\
|
|
*(FAR type *)ptr = value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
}
|
|
|
|
#define LOAD(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR const volatile void *ptr, \
|
|
int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
\
|
|
type ret = *(FAR type *)ptr; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define EXCHANGE(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value, int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
type ret = *tmp; \
|
|
*tmp = value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define CMP_EXCHANGE(fn, n, type) \
|
|
\
|
|
bool weak_function CONCATENATE(fn, n)(FAR volatile void *mem, \
|
|
FAR volatile void *expect, \
|
|
type desired, bool weak, \
|
|
int success, int failure) \
|
|
{ \
|
|
bool ret = false; \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmpmem = (FAR type *)mem; \
|
|
FAR type *tmpexp = (FAR type *)expect; \
|
|
\
|
|
if (*tmpmem == *tmpexp) \
|
|
{ \
|
|
ret = true; \
|
|
*tmpmem = desired; \
|
|
} \
|
|
else \
|
|
{ \
|
|
*tmpexp = *tmpmem; \
|
|
} \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define FLAG_TEST_AND_SET(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
type ret = *tmp; \
|
|
\
|
|
*(FAR type *)ptr = 1; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define FETCH_ADD(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value, int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
type ret = *tmp; \
|
|
\
|
|
*tmp = *tmp + value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define FETCH_SUB(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value, int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
type ret = *tmp; \
|
|
\
|
|
*tmp = *tmp - value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define FETCH_AND(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value, int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
type ret = *tmp; \
|
|
\
|
|
*tmp = *tmp & value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define FETCH_OR(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value, int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
type ret = *tmp; \
|
|
\
|
|
*tmp = *tmp | value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define FETCH_XOR(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value, int memorder) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
type ret = *tmp; \
|
|
\
|
|
*tmp = *tmp ^ value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define SYNC_ADD_FETCH(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
*tmp = *tmp + value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return *tmp; \
|
|
}
|
|
|
|
#define SYNC_SUB_FETCH(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
*tmp = *tmp - value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return *tmp; \
|
|
}
|
|
|
|
#define SYNC_OR_FETCH(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
*tmp = *tmp | value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return *tmp; \
|
|
}
|
|
|
|
#define SYNC_AND_FETCH(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
*tmp = *tmp & value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return *tmp; \
|
|
}
|
|
|
|
#define SYNC_XOR_FETCH(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
*tmp = *tmp ^ value; \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return *tmp; \
|
|
}
|
|
|
|
#define SYNC_NAND_FETCH(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type value) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
*tmp = ~(*tmp & value); \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return *tmp; \
|
|
}
|
|
|
|
#define SYNC_BOOL_CMP_SWAP(fn, n, type) \
|
|
\
|
|
bool weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type oldvalue, \
|
|
type newvalue) \
|
|
{ \
|
|
bool ret = false; \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
\
|
|
if (*tmp == oldvalue) \
|
|
{ \
|
|
ret = true; \
|
|
*tmp = newvalue; \
|
|
} \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#define SYNC_VAL_CMP_SWAP(fn, n, type) \
|
|
\
|
|
type weak_function CONCATENATE(fn, n)(FAR volatile void *ptr, \
|
|
type oldvalue, \
|
|
type newvalue) \
|
|
{ \
|
|
irqstate_t irqstate = atomic_lock(); \
|
|
FAR type *tmp = (FAR type *)ptr; \
|
|
type ret = *tmp; \
|
|
\
|
|
if (*tmp == oldvalue) \
|
|
{ \
|
|
*tmp = newvalue; \
|
|
} \
|
|
\
|
|
atomic_unlock(irqstate); \
|
|
return ret; \
|
|
}
|
|
|
|
#endif /* __LIBS_LIBC_MACHINE_ARCH_ATOMIC_H */
|