arch_atomic: support nx atomic function

Modify the kernel to use nx atomic interfaces, avoiding
the use of sizeof or typeof to determine the type of
atomic operations, thereby simplifying the kernel's atomic
interface operations.

Signed-off-by: zhangyuan29 <[email protected]>

arch/arm/src/cxd56xx/cxd56_sph.c

@@ -104,7 +104,7 @@ static int sph_open(struct file *filep)
 {
   /* Exclusive access */
 
-  if (atomic_load(&filep->f_inode->i_crefs) > 2)
+  if (atomic_read(&filep->f_inode->i_crefs) > 2)
     {
       return ERROR;
     }

arch/arm/src/cxd56xx/cxd56_uart0.c

@@ -115,7 +115,7 @@ static int uart0_open(struct file *filep)
   int stop;
   int ret;
 
-  if (atomic_load(&inode->i_crefs) > 2)
+  if (atomic_read(&inode->i_crefs) > 2)
     {
       return OK;
     }
@@ -172,7 +172,7 @@ static int uart0_close(struct file *filep)
 {
   struct inode *inode = filep->f_inode;
 
-  if (atomic_load(&inode->i_crefs) == 2)
+  if (atomic_read(&inode->i_crefs) == 2)
     {
       fw_pd_uartdisable(0);
       fw_pd_uartuninit(0);

arch/sim/src/sim/sim_heap.c

@@ -184,8 +184,8 @@ static void mm_delayfree(struct mm_heap_s *heap, void *mem, bool delay)
   else
     {
       int size = host_mallocsize(mem);
-      atomic_fetch_sub(&heap->aordblks, 1);
-      atomic_fetch_sub(&heap->uordblks, size);
+      atomic_fetch_sub_full(&heap->aordblks, 1);
+      atomic_fetch_sub_full(&heap->uordblks, size);
       sched_note_heap(NOTE_HEAP_FREE, heap, mem, size, 0);
       host_free(mem);
     }
@@ -379,12 +379,12 @@ void *mm_realloc(struct mm_heap_s *heap, void *oldmem,
     }
 
   oldsize = host_mallocsize(oldmem);
-  atomic_fetch_sub(&heap->uordblks, oldsize);
+  atomic_fetch_sub_full(&heap->uordblks, oldsize);
   mem = host_realloc(oldmem, size);
 
-  atomic_fetch_add(&heap->aordblks, oldmem == NULL && mem != NULL);
+  atomic_fetch_add_full(&heap->aordblks, oldmem == NULL && mem != NULL);
   newsize = host_mallocsize(mem ? mem : oldmem);
-  atomic_fetch_add(&heap->uordblks, newsize);
+  atomic_fetch_add_full(&heap->uordblks, newsize);
   usmblks = atomic_load(&heap->usmblks);
   if (mem != NULL)
     {
@@ -404,7 +404,7 @@ void *mm_realloc(struct mm_heap_s *heap, void *oldmem,
           break;
         }
     }
-  while (atomic_compare_exchange_weak(&heap->usmblks, &usmblks, uordblks));
+  while (atomic_try_cmpxchg(&heap->usmblks, &usmblks, uordblks));
 
 #if CONFIG_MM_FREE_DELAYCOUNT_MAX > 0
   if (mem == NULL && free_delaylist(heap, true))
@@ -486,8 +486,8 @@ void *mm_memalign(struct mm_heap_s *heap, size_t alignment, size_t size)
 
   size = host_mallocsize(mem);
   sched_note_heap(NOTE_HEAP_ALLOC, heap, mem, size, 0);
-  atomic_fetch_add(&heap->aordblks, 1);
-  atomic_fetch_add(&heap->uordblks, size);
+  atomic_fetch_add_full(&heap->aordblks, 1);
+  atomic_fetch_add_full(&heap->uordblks, size);
   usmblks = atomic_load(&heap->usmblks);
 
   do
@@ -498,7 +498,7 @@ void *mm_memalign(struct mm_heap_s *heap, size_t alignment, size_t size)
           break;
         }
     }
-  while (atomic_compare_exchange_weak(&heap->usmblks, &usmblks, uordblks));
+  while (atomic_try_cmpxchg(&heap->usmblks, &usmblks, uordblks));
 
 #if CONFIG_MM_FREE_DELAYCOUNT_MAX > 0
   if (mem == NULL && free_delaylist(heap, true))

drivers/i3c/master.c

@@ -1180,8 +1180,8 @@ static void i3c_master_handle_ibi(FAR void *arg)
     }
 
   master->ops->recycle_ibi_slot(dev, slot);
-  atomic_fetch_sub(&dev->ibi->pending_ibis, 1);
-  if (!atomic_load(&dev->ibi->pending_ibis))
+  atomic_fetch_sub_full(&dev->ibi->pending_ibis, 1);
+  if (!atomic_read(&dev->ibi->pending_ibis))
     {
       sem_post(&dev->ibi->all_ibis_handled);
     }
@@ -1800,7 +1800,7 @@ int i3c_master_add_i3c_dev_locked(FAR struct i3c_master_controller *master,
 void i3c_master_queue_ibi(FAR struct i3c_dev_desc *dev,
                           FAR struct i3c_ibi_slot *slot)
 {
-  atomic_fetch_add(&dev->ibi->pending_ibis, 1);
+  atomic_fetch_add_full(&dev->ibi->pending_ibis, 1);
   work_queue(HPWORK, &slot->work, i3c_master_handle_ibi, slot, 0);
 }
 
@@ -2034,7 +2034,7 @@ int i3c_dev_disable_ibi_locked(FAR struct i3c_dev_desc *dev)
       return ret;
     }
 
-  if (atomic_load(&dev->ibi->pending_ibis))
+  if (atomic_read(&dev->ibi->pending_ibis))
     {
       sem_wait(&dev->ibi->all_ibis_handled);
     }
@@ -2087,7 +2087,7 @@ int i3c_dev_request_ibi_locked(FAR struct i3c_dev_desc *dev,
       return -ENOMEM;
     }
 
-  atomic_init(&ibi->pending_ibis, 0);
+  atomic_set(&ibi->pending_ibis, 0);
   sem_init(&ibi->all_ibis_handled, 0, 1);
   ibi->handler = req->handler;
   ibi->max_payload_len = req->max_payload_len;

drivers/input/aw86225.c

@@ -956,7 +956,7 @@ static int aw86225_haptic_rtp_init(FAR struct aw86225 *aw86225)
   nxmutex_lock(&aw86225->rtp_lock);
   while ((!aw86225_haptic_rtp_get_fifo_afs(aw86225))
          && (aw86225->play_mode == AW86225_HAPTIC_RTP_MODE)
-         &&  !atomic_load(&aw86225->exit_in_rtp_loop))
+         &&  !atomic_read(&aw86225->exit_in_rtp_loop))
     {
       if (!aw86225->rtp_container)
         {
@@ -1014,7 +1014,7 @@ static int aw86225_haptic_rtp_init(FAR struct aw86225 *aw86225)
 
   nxmutex_unlock(&aw86225->rtp_lock);
   if (aw86225->play_mode == AW86225_HAPTIC_RTP_MODE
-      && !atomic_load(&aw86225->exit_in_rtp_loop))
+      && !atomic_read(&aw86225->exit_in_rtp_loop))
     {
       aw86225_haptic_set_rtp_aei(aw86225, true);
     }
@@ -1121,24 +1121,24 @@ static void aw86225_rtp_work_routine(FAR void *arg)
 
   /* wait for irq to exit */
 
-  atomic_store(&aw86225->exit_in_rtp_loop, 1);
-  while (atomic_load(&aw86225->is_in_rtp_loop))
+  atomic_set(&aw86225->exit_in_rtp_loop, 1);
+  while (atomic_read(&aw86225->is_in_rtp_loop))
     {
       iinfo("%s:  goint to waiting irq exit\n", __func__);
 
       ret = nxsem_wait(&aw86225->wait_q);
 
       if (ret == -ERESTART)
         {
-          atomic_store(&aw86225->exit_in_rtp_loop, 0);
+          atomic_set(&aw86225->exit_in_rtp_loop, 0);
           nxsem_post(&aw86225->stop_wait_q);
           nxmutex_unlock(&aw86225->lock);
           ierr("%s: wake up by signal return erro\n", __func__);
           return;
         }
     }
 
-  atomic_store(&aw86225->exit_in_rtp_loop, 0);
+  atomic_set(&aw86225->exit_in_rtp_loop, 0);
   nxsem_post(&aw86225->stop_wait_q);
   aw86225_haptic_stop(aw86225);
 
@@ -2155,7 +2155,7 @@ static int aw86225_haptics_upload_effect(FAR struct ff_lowerhalf_s *lower,
 
   aw86225->effect_type = effect->type;
   nxmutex_lock(&aw86225->lock);
-  while (atomic_load(&aw86225->exit_in_rtp_loop))
+  while (atomic_read(&aw86225->exit_in_rtp_loop))
     {
       iinfo("%s: goint to waiting rtp exit\n", __func__);
       nxmutex_unlock(&aw86225->lock);

drivers/input/aw86225_internal.h

@@ -29,10 +29,10 @@
 
 #include <nuttx/config.h>
 
-#include <stdatomic.h>
 #include <stdio.h>
 #include <time.h>
 
+#include <nuttx/atomic.h>
 #include <nuttx/i2c/i2c_master.h>
 #include <nuttx/input/ff.h>
 #include <nuttx/wqueue.h>
@@ -287,8 +287,8 @@ struct aw86225
   unsigned char level;
   unsigned int osc_cali_run;
   unsigned char ram_vbat_comp;
-  atomic_int is_in_rtp_loop;
-  atomic_int exit_in_rtp_loop;
+  atomic_t is_in_rtp_loop;
+  atomic_t exit_in_rtp_loop;
   sem_t wait_q;
   sem_t stop_wait_q;
 };

drivers/net/netdev_upperhalf.c

@@ -155,7 +155,7 @@ static FAR netpkt_t *netpkt_get(FAR struct net_driver_s *dev,
    * cases will be limited by netdev_upper_can_tx and seldom reaches here.
    */
 
-  if (atomic_fetch_sub(&upper->lower->quota[type], 1) <= 0)
+  if (atomic_fetch_sub_full(&upper->lower->quota[type], 1) <= 0)
     {
       nwarn("WARNING: Allowing temperarily exceeding quota of %s.\n",
             dev->d_ifname);
@@ -187,7 +187,7 @@ static void netpkt_put(FAR struct net_driver_s *dev, FAR netpkt_t *pkt,
    *       but we don't want these changes.
    */
 
-  atomic_fetch_add(&upper->lower->quota[type], 1);
+  atomic_fetch_add_full(&upper->lower->quota[type], 1);
   netdev_iob_release(dev);
   dev->d_iob = pkt;
   dev->d_len = netpkt_getdatalen(upper->lower, pkt);
@@ -1369,7 +1369,7 @@ void netdev_lower_txdone(FAR struct netdev_lowerhalf_s *dev)
  * Name: netdev_lower_quota_load
  *
  * Description:
- *   Fetch the quota, works like atomic_load.
+ *   Fetch the quota, works like atomic_read.
  *
  * Input Parameters:
  *   dev  - The lower half device driver structure
@@ -1380,7 +1380,7 @@ void netdev_lower_txdone(FAR struct netdev_lowerhalf_s *dev)
 int netdev_lower_quota_load(FAR struct netdev_lowerhalf_s *dev,
                             enum netpkt_type_e type)
 {
-  return atomic_load(&dev->quota[type]);
+  return atomic_read(&dev->quota[type]);
 }
 
 /****************************************************************************
@@ -1403,16 +1403,16 @@ FAR netpkt_t *netpkt_alloc(FAR struct netdev_lowerhalf_s *dev,
 {
   FAR netpkt_t *pkt;
 
-  if (atomic_fetch_sub(&dev->quota[type], 1) <= 0)
+  if (atomic_fetch_sub_full(&dev->quota[type], 1) <= 0)
     {
-      atomic_fetch_add(&dev->quota[type], 1);
+      atomic_fetch_add_full(&dev->quota[type], 1);
       return NULL;
     }
 
   pkt = iob_tryalloc(false);
   if (pkt == NULL)
     {
-      atomic_fetch_add(&dev->quota[type], 1);
+      atomic_fetch_add_full(&dev->quota[type], 1);
       return NULL;
     }
 
@@ -1436,7 +1436,7 @@ FAR netpkt_t *netpkt_alloc(FAR struct netdev_lowerhalf_s *dev,
 void netpkt_free(FAR struct netdev_lowerhalf_s *dev, FAR netpkt_t *pkt,
                  enum netpkt_type_e type)
 {
-  atomic_fetch_add(&dev->quota[type], 1);
+  atomic_fetch_add_full(&dev->quota[type], 1);
   iob_free_chain(pkt);
 }
 

drivers/note/notesnap_driver.c

@@ -50,8 +50,8 @@ struct notesnap_s
 {
   struct note_driver_s driver;
   struct notifier_block nb;
-  atomic_int index;
-  atomic_bool dumping;
+  atomic_t index;
+  atomic_t dumping;
   struct notesnap_chunk_s buffer[CONFIG_DRIVERS_NOTESNAP_NBUFFERS];
 };
 
@@ -212,14 +212,14 @@ static inline void notesnap_common(FAR struct note_driver_s *drv,
   FAR struct notesnap_chunk_s *note;
   size_t index;
 
-  if (atomic_load(&snap->dumping))
+  if (atomic_read(&snap->dumping))
     {
       return;
     }
 
   /* Atomic operation, equivalent to snap.index++; */
 
-  index = atomic_fetch_add(&snap->index, 1);
+  index = atomic_fetch_add_full(&snap->index, 1);
   note = &snap->buffer[index % CONFIG_DRIVERS_NOTESNAP_NBUFFERS];
 
   note->type = type;
@@ -388,7 +388,7 @@ void notesnap_dump_with_stream(FAR struct lib_outstream_s *stream)
 
   /* Stop recording while dumping */
 
-  atomic_store(&g_notesnap.dumping, true);
+  atomic_set(&g_notesnap.dumping, true);
 
   for (i = 0; i < CONFIG_DRIVERS_NOTESNAP_NBUFFERS; i++)
     {
@@ -411,7 +411,7 @@ void notesnap_dump_with_stream(FAR struct lib_outstream_s *stream)
                   note->pid, g_notesnap_type[note->type], note->args);
     }
 
-  atomic_store(&g_notesnap.dumping, false);
+  atomic_set(&g_notesnap.dumping, false);
 }
 
 /****************************************************************************

drivers/reset/core.c

@@ -280,7 +280,7 @@ reset_control_get_internal(FAR struct reset_controller_dev *rcdev,
               return NULL;
             }
 
-          atomic_fetch_add(&rstc->refcnt, 1);
+          atomic_fetch_add_full(&rstc->refcnt, 1);
           return rstc;
         }
     }
@@ -310,7 +310,7 @@ reset_control_get_internal(FAR struct reset_controller_dev *rcdev,
   rstc->rcdev = rcdev;
   list_add_after(&rcdev->reset_control_head, &rstc->list);
   rstc->id = index;
-  atomic_init(&rstc->refcnt, 1);
+  atomic_set(&rstc->refcnt, 1);
   rstc->acquired = acquired;
   rstc->shared = shared;
 
@@ -332,7 +332,7 @@ static void reset_control_put_internal(FAR struct reset_control *rstc)
 {
   DEBUGASSERT(nxmutex_is_locked(&g_reset_list_mutex));
 
-  if (atomic_fetch_sub(&rstc->refcnt, 1) == 1)
+  if (atomic_fetch_sub_full(&rstc->refcnt, 1) == 1)
     {
       DEBUGASSERT(nxmutex_is_locked(&g_reset_list_mutex));
       list_delete(&rstc->list);
@@ -528,12 +528,12 @@ int reset_control_reset(FAR struct reset_control *rstc)
 
   if (rstc->shared)
     {
-      if (atomic_load(&rstc->deassert_count) != 0)
+      if (atomic_read(&rstc->deassert_count) != 0)
         {
           return -EINVAL;
         }
 
-      if (atomic_fetch_add(&rstc->triggered_count, 1) != 0)
+      if (atomic_fetch_add_full(&rstc->triggered_count, 1) != 0)
         {
           return 0;
         }
@@ -552,7 +552,7 @@ int reset_control_reset(FAR struct reset_control *rstc)
 
   if (rstc->shared && ret < 0)
     {
-      atomic_fetch_sub(&rstc->triggered_count, 1);
+      atomic_fetch_sub_full(&rstc->triggered_count, 1);
     }
 
   return ret;
@@ -598,18 +598,18 @@ int reset_control_assert(FAR struct reset_control *rstc)
 
   if (rstc->shared)
     {
-      if (atomic_load(&rstc->triggered_count) != 0)
+      if (atomic_read(&rstc->triggered_count) != 0)
         {
           return -EINVAL;
         }
 
-      if (atomic_load(&rstc->deassert_count) == 0)
+      if (atomic_read(&rstc->deassert_count) == 0)
         {
           rsterr("deassert_count = 0, invalid value\n");
           return -EINVAL;
         }
 
-      if (atomic_fetch_sub(&rstc->deassert_count, 1) != 1)
+      if (atomic_fetch_sub_full(&rstc->deassert_count, 1) != 1)
         {
           return 0;
         }
@@ -682,13 +682,13 @@ int reset_control_deassert(FAR struct reset_control *rstc)
 
   if (rstc->shared)
     {
-      if (atomic_load(&rstc->triggered_count) != 0)
+      if (atomic_read(&rstc->triggered_count) != 0)
         {
           rsterr("triggered_count != 0, invalid value\n");
           return -EINVAL;
         }
 
-      if (atomic_fetch_add(&rstc->deassert_count, 1) != 0)
+      if (atomic_fetch_add_full(&rstc->deassert_count, 1) != 0)
         {
           return 0;
         }