libatomic.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#ifdef ESP_NONOS
 
#ifndef __STRINGIFY
#define __STRINGIFY(a) #a
#endif
 
// these low level routines provide a replacement for SREG interrupt save that AVR uses
// but are esp8266 specific. A normal use pattern is like
//
//{
//    uint32_t savedPS = xt_rsil(1); // this routine will allow level 2 and above
//    // do work here
//    xt_wsr_ps(savedPS); // restore the state
//}
//
// level (0-15), interrupts of the given level and above will be active
// level 15 will disable ALL interrupts,
// level 0 will enable ALL interrupts,
//
#define xt_rsil(level) (__extension__({uint32_t state; __asm__ __volatile__("rsil %0," __STRINGIFY(level) : "=a" (state)); state;}))
#define xt_wsr_ps(state)  __asm__ __volatile__("wsr %0,ps; isync" :: "a" (state) : "memory")
 
 
#define ACQ_LOCK()                              \
    uint32_t savedPS = xt_rsil(15);
 
#define REL_LOCK()  xt_wsr_ps(savedPS);
 
#elif defined(STM32F0xx) || (!defined(ARDUINO) && !defined(ESP_PLATFORM))
// On Cortex-M0 the only way to do atomic operation is to disable interrupts.
 
#define ACQ_LOCK()                                                             \
    int _pastlock;                                                             \
    __asm volatile(" mrs %0, PRIMASK \n cpsid i\n" : "=r"(_pastlock));
 
#define REL_LOCK() __asm volatile(" msr PRIMASK, %0\n " : : "r"(_pastlock));
 
#endif
 
 
 
 
#ifdef ACQ_LOCK
 
 
uint8_t __atomic_fetch_add_1(uint8_t *ptr, uint8_t val, int memorder)
{
    ACQ_LOCK();
    uint16_t ret = *ptr;
    *ptr += val;
    REL_LOCK();
    return ret;
}
 
uint16_t __atomic_fetch_sub_2(uint16_t *ptr, uint16_t val, int memorder)
{
    ACQ_LOCK();
    uint16_t ret = *ptr;
    *ptr -= val;
    REL_LOCK();
    return ret;
}
 
uint8_t __atomic_fetch_or_1(uint8_t *ptr, uint8_t val, int memorder)
{
    ACQ_LOCK();
    uint8_t ret = *ptr;
    *ptr = ret | val;
    REL_LOCK();
    return ret;
}
 
uint32_t __atomic_fetch_or_4(uint32_t *ptr, uint32_t val, int memorder)
{
    ACQ_LOCK();
    uint32_t ret = *ptr;
    *ptr = ret | val;
    REL_LOCK();
    return ret;
}
 
uint8_t __atomic_fetch_and_1(uint8_t *ptr, uint8_t val, int memorder)
{
    ACQ_LOCK();
    uint8_t ret = *ptr;
    *ptr = ret & val;
    REL_LOCK();
    return ret;
}
 
uint32_t __atomic_fetch_and_4(uint32_t *ptr, uint32_t val, int memorder)
{
    ACQ_LOCK();
    uint32_t ret = *ptr;
    *ptr = ret & val;
    REL_LOCK();
    return ret;
}
 
uint8_t __atomic_exchange_1(uint8_t *ptr, uint8_t val, int memorder)
{
    ACQ_LOCK();
    uint8_t ret = *ptr;
    *ptr = val;
    REL_LOCK();
    return ret;
}
 
_Bool __atomic_compare_exchange_1(uint8_t *ptr, uint8_t *exp, uint8_t desired,
    _Bool weak, int success_memorder, int failure_memorder)
{
    ACQ_LOCK();
    uint8_t curr = *ptr;
    if (curr == *exp)
    {
        *ptr = desired;
        REL_LOCK();
        return 1;
    }
    *exp = curr;
    REL_LOCK();
    return 0;
}
 
_Bool __atomic_compare_exchange_4(uint32_t *ptr, uint32_t *exp,
    uint32_t desired, _Bool weak, int success_memorder, int failure_memorder)
{
    ACQ_LOCK();
    uint32_t curr = *ptr;
    if (curr == *exp)
    {
        *ptr = desired;
        REL_LOCK();
        return 1;
    }
    *exp = curr;
    REL_LOCK();
    return 0;
}
 
#endif // guard for arduino compilation