iot_atomic_generic.h

Go to the documentation of this file.

/*
 * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef IOT_ATOMIC_GENERIC_H_
#define IOT_ATOMIC_GENERIC_H_

/* Standard includes. */
#include <stdint.h>

/* Atomic include. */
#include "iot_atomic.h"

/* Platform threads include. */
#include "platform/iot_threads.h"

/* Ensure that this header is only included when generic atomics are enabled. */
#if IOT_ATOMIC_GENERIC != 1
    #error "Generic atomic implementation is not enabled."
#endif

extern void Iot_EnterCritical( void );
extern void Iot_ExitCritical( void );
/*---------------- Swap and compare-and-swap ------------------*/

/* @[declare_platform_atomic_compareandswap_u32] */
static inline uint32_t Atomic_CompareAndSwap_u32( uint32_t volatile * pDestination,
                                                  uint32_t newValue,
                                                  uint32_t comparand )
/* @[declare_platform_atomic_compareandswap_u32] */
{
    uint32_t swapped = 0;

    Iot_EnterCritical();

    if( *pDestination == comparand )
    {
        *pDestination = newValue;
        swapped = 1;
    }

    Iot_ExitCritical();

    return swapped;
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_swap_pointer] */
static inline void * Atomic_Swap_Pointer( void * volatile * pDestination,
                                          void * pNewValue )
/* @[declare_platform_atomic_swap_pointer] */
{
    void * pOldValue = NULL;

    Iot_EnterCritical();
    pOldValue = *pDestination;
    *pDestination = pNewValue;
    Iot_ExitCritical();

    return pOldValue;
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_compareandswap_pointer] */
static inline uint32_t Atomic_CompareAndSwap_Pointer( void * volatile * pDestination,
                                                      void * pNewValue,
                                                      void * pComparand )
/* @[declare_platform_atomic_compareandswap_pointer] */
{
    uint32_t swapped = 0;

    Iot_EnterCritical();

    if( *pDestination == pComparand )
    {
        *pDestination = pNewValue;
        swapped = 1;
    }

    Iot_ExitCritical();

    return swapped;
}

/*----------------------- Arithmetic --------------------------*/

/* @[declare_platform_atomic_add_u32] */
static inline uint32_t Atomic_Add_u32( uint32_t volatile * pAugend,
                                       uint32_t addend )
/* @[declare_platform_atomic_add_u32] */
{
    uint32_t oldValue = 0;

    Iot_EnterCritical();
    oldValue = *pAugend;
    *pAugend = oldValue + addend;
    Iot_ExitCritical();

    return oldValue;
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_subtract_u32] */
static inline uint32_t Atomic_Subtract_u32( uint32_t volatile * pMinuend,
                                            uint32_t subtrahend )
/* @[declare_platform_atomic_subtract_u32] */
{
    uint32_t oldValue = 0;

    Iot_EnterCritical();
    oldValue = *pMinuend;
    *pMinuend = oldValue - subtrahend;
    Iot_ExitCritical();

    return oldValue;
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_increment_u32] */
static inline uint32_t Atomic_Increment_u32( uint32_t volatile * pAugend )
/* @[declare_platform_atomic_increment_u32] */
{
    return Atomic_Add_u32( pAugend, 1 );
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_decrement_u32] */
static inline uint32_t Atomic_Decrement_u32( uint32_t volatile * pMinuend )
/* @[declare_platform_atomic_decrement_u32] */
{
    return Atomic_Subtract_u32( pMinuend, 1 );
}

/*--------------------- Bitwise logic -------------------------*/

/* @[declare_platform_atomic_or_u32] */
static inline uint32_t Atomic_OR_u32( uint32_t volatile * pOperand,
                                      uint32_t mask )
/* @[declare_platform_atomic_or_u32] */
{
    uint32_t oldValue = 0;

    Iot_EnterCritical();
    oldValue = *pOperand;
    *pOperand = ( oldValue | mask );
    Iot_ExitCritical();

    return oldValue;
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_xor_u32] */
static inline uint32_t Atomic_XOR_u32( uint32_t volatile * pOperand,
                                       uint32_t mask )
/* @[declare_platform_atomic_xor_u32] */
{
    uint32_t oldValue = 0;

    Iot_EnterCritical();
    oldValue = *pOperand;
    *pOperand = ( oldValue ^ mask );
    Iot_ExitCritical();

    return oldValue;
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_and_u32] */
static inline uint32_t Atomic_AND_u32( uint32_t volatile * pOperand,
                                       uint32_t mask )
/* @[declare_platform_atomic_and_u32] */
{
    uint32_t oldValue = 0;

    Iot_EnterCritical();
    oldValue = *pOperand;
    *pOperand = ( oldValue & mask );
    Iot_ExitCritical();

    return oldValue;
}

/*-----------------------------------------------------------*/

/* @[declare_platform_atomic_nand_u32] */
static inline uint32_t Atomic_NAND_u32( uint32_t volatile * pOperand,
                                        uint32_t mask )
/* @[declare_platform_atomic_nand_u32] */
{
    uint32_t oldValue = 0;

    Iot_EnterCritical();
    oldValue = *pOperand;
    *pOperand = ~( oldValue & mask );
    Iot_ExitCritical();

    return oldValue;
}

#endif /* ifndef IOT_ATOMIC_GENERIC_H_ */