/*
 * Copyright (c) 2023 - 2025, Nordic Semiconductor ASA
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef NRFY_NFCT_H__
#define NRFY_NFCT_H__

#include <nrfx.h>
#include <hal/nrf_nfct.h>

#ifdef __cplusplus
extern "C" {
#endif

NRFY_STATIC_INLINE void __nrfy_internal_nfct_event_enabled_clear(NRF_NFCT_Type *  p_reg,
                                                                 uint32_t         mask,
                                                                 nrf_nfct_event_t event);

NRFY_STATIC_INLINE bool __nrfy_internal_nfct_event_handle(NRF_NFCT_Type  * p_reg,
                                                          uint32_t         mask,
                                                          nrf_nfct_event_t event,
                                                          uint32_t       * p_evt_mask);

NRFY_STATIC_INLINE uint32_t __nrfy_internal_nfct_events_process(NRF_NFCT_Type * p_reg,
                                                                uint32_t        mask);

/**
 * @defgroup nrfy_nfct NFCT HALY
 * @{
 * @ingroup nrf_nfct
 * @brief   Hardware access layer with cache and barrier support for managing the NFCT peripheral.
 */

#if NRF_NFCT_HAS_MODULATION_PSEL_REG || defined(__NRFX_DOXYGEN__)
/** @refhal{NRF_NFCT_HAS_MODULATION_PSEL_REG} */
#define NRFY_NFCT_HAS_MODULATION_PSEL_REG 1
#else
#define NRFY_NFCT_HAS_MODULATION_PSEL_REG 0
#endif

#if NRF_NFCT_HAS_MODULATION_CTRL_REG || defined(__NRFX_DOXYGEN__)
/** @refhal{NRF_NFCT_HAS_MODULATION_CTRL_REG} */
#define NRFY_NFCT_HAS_MODULATION_CTRL_REG 1
#else
#define NRFY_NFCT_HAS_MODULATION_CTRL_REG 0
#endif

#if NRF_NFCT_HAS_TAG_STATE_REG || defined(__NRFX_DOXYGEN__)
/** @refhal{NRF_NFCT_HAS_TAG_STATE_REG} */
#define NRFY_NFCT_HAS_TAG_STATE_REG 1
#else
#define NRFY_NFCT_HAS_TAG_STATE_REG 0
#endif

#if NRF_NFCT_HAS_SLEEP_STATE_REG || defined(__NRFX_DOXYGEN__)
/** @refhal{NRF_NFCT_HAS_SLEEP_STATE_REG} */
#define NRFY_NFCT_HAS_SLEEP_STATE_REG 1
#else
#define NRFY_NFCT_HAS_SLEEP_STATE_REG 0
#endif

#if NRF_NFCT_HAS_AUTOCOLRES_CONFIG_REG || defined(__NRFX_DOXYGEN__)
/** @refhal{NRF_NFCT_HAS_AUTOCOLRES_CONFIG_REG} */
#define NRFY_NFCT_HAS_AUTOCOLRES_CONFIG_REG 1
#else
#define NRFY_NFCT_HAS_AUTOCOLRES_CONFIG_REG 0
#endif

#if NRF_NFCT_HAS_PAD_CONFIG_REG || defined(__NRFX_DOXYGEN__)
/** @refhal{NRF_NFCT_HAS_PAD_CONFIG_REG} */
#define NRFY_NFCT_HAS_PAD_CONFIG_REG 1
#else
#define NRFY_NFCT_HAS_PAD_CONFIG_REG 0
#endif

#if NRF_NFCT_HAS_BIAS_CONFIG_TRIM_REG || defined(__NRFX_DOXYGEN__)
/** @refhal{NRF_NFCT_HAS_BIAS_CONFIG_TRIM_REG} */
#define NRFY_NFCT_HAS_BIAS_CONFIG_TRIM_REG 1
#else
#define NRFY_NFCT_HAS_BIAS_CONFIG_TRIM_REG 0
#endif

/** @brief NFCT parameters storage structure. */
typedef struct
{
    uint32_t                       fdmax;                                       ///< Frame delay max value.
    uint32_t                       fdmin;                                       ///< Frame delay min value.
    uint32_t                       int_enabled;                                 ///< Interrupts status.
    uint8_t                        nfcid1[NRF_NFCT_SENSRES_NFCID1_SIZE_TRIPLE]; ///< NFCID1 value.
    nrf_nfct_sensres_nfcid1_size_t nfcid1_size;                                 ///< NFCID1 size.
    nrf_nfct_selres_protocol_t     protocol;                                    ///< NFC protocol type.
} nrfy_nfct_parameters_t;

/**
 * @brief Function for initializing the specified NFCT interrupts.
 *
 * @param[in] p_reg        Pointer to the structure of registers of the peripheral.
 * @param[in] mask         Mask of interrupts to be initialized.
 * @param[in] irq_priority Interrupts priority.
 * @param[in] enable       True if interrupts associated with the event mask are to be enabled,
 *                         false otherwise.
 */
NRFY_STATIC_INLINE void nrfy_nfct_int_init(NRF_NFCT_Type * p_reg,
                                           uint32_t        mask,
                                           uint8_t         irq_priority,
                                           bool            enable)
{
    IRQn_Type nfct_irq = nrfx_get_irq_number(p_reg);

    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_READY);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_FIELDDETECTED);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_FIELDLOST);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_TXFRAMESTART);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_TXFRAMEEND);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_RXFRAMESTART);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_RXFRAMEEND);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_ERROR);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_RXERROR);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_ENDRX);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_ENDTX);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_AUTOCOLRESSTARTED);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_COLLISION);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_SELECTED);
    __nrfy_internal_nfct_event_enabled_clear(p_reg, mask, NRF_NFCT_EVENT_STARTED);
    nrf_barrier_w();

    NRFY_IRQ_PENDING_CLEAR(nfct_irq);
    nrf_barrier_w();

    NRFY_IRQ_PRIORITY_SET(nfct_irq, irq_priority);
    NRFY_IRQ_ENABLE(nfct_irq);

    if (enable)
    {
        nrf_nfct_int_enable(p_reg, mask);
    }

    nrf_barrier_w();
}

/**
 * @brief Function for un-initializing the NFCT interrupts.
 *
 * @param[in] p_reg Pointer to the structure of registers of the peripheral.
 */
NRFY_STATIC_INLINE void nrfy_nfct_int_uninit(NRF_NFCT_Type * p_reg)
{
    IRQn_Type nfct_irq = nrfx_get_irq_number(p_reg);

    NRFY_IRQ_DISABLE(nfct_irq);
    nrf_barrier_w();
    NRFY_IRQ_PENDING_CLEAR(nfct_irq);
    nrf_barrier_w();
}

/**
 * @brief Function for processing the specified NFCT events.
 *
 * @param[in] p_reg Pointer to the structure of registers of the peripheral.
 * @param[in] mask  Mask of the events to be processed, created by the
 *                  @ref NRFY_EVENT_TO_INT_BITMASK().
 *
 * @return Mask of the events that were generated and processed.
 *         To be checked against the result of the @ref NRFY_EVENT_TO_INT_BITMASK().
*/
NRFY_STATIC_INLINE uint32_t nrfy_nfct_events_process(NRF_NFCT_Type * p_reg, uint32_t mask)
{
    uint32_t evt_mask = __nrfy_internal_nfct_events_process(p_reg, mask);
    nrf_barrier_w();
    return evt_mask;
}

/**
 * @brief Function for saving NFCT parameters before peripheral reset.
 *
 * @param[in] p_reg    Pointer to the structure of registers of the peripheral.
 * @param[in] p_params Pointer to the structure where the parameters will be saved.
*/
NRFY_STATIC_INLINE void nrfy_nfct_parameters_save(NRF_NFCT_Type const *    p_reg,
                                                  nrfy_nfct_parameters_t * p_params)
{
    nrf_barrier_rw();
    p_params->fdmax       = nrf_nfct_frame_delay_max_get(p_reg);
    p_params->fdmin       = nrf_nfct_frame_delay_min_get(p_reg);
    p_params->nfcid1_size = nrf_nfct_nfcid1_get(p_reg, p_params->nfcid1);
    p_params->protocol    = nrf_nfct_selres_protocol_get(p_reg);
    p_params->int_enabled = nrf_nfct_int_enable_get(p_reg);
    nrf_barrier_r();
}

/**
 * @brief Function for restoring NFCT parameters after peripheral reset. The parameters are
 *        written back to the peripheral registers.
 *
 * @param[in] p_reg    Pointer to the structure of registers of the peripheral.
 * @param[in] p_params Pointer to the structure holding peripheral parameters to be restored.
 */
NRFY_STATIC_INLINE void nrfy_nfct_parameters_restore(NRF_NFCT_Type *                p_reg,
                                                     nrfy_nfct_parameters_t const * p_params)
{
    nrf_nfct_frame_delay_max_set(p_reg, p_params->fdmax);
    nrf_nfct_frame_delay_min_set(p_reg, (uint16_t)p_params->fdmin);
    nrf_nfct_nfcid1_set(p_reg, p_params->nfcid1, p_params->nfcid1_size);
    nrf_nfct_selres_protocol_set(p_reg, p_params->protocol);

    nrf_barrier_w();
}

/**
 * @brief Function for setting the the NFCT RX/TX buffer (address and maximum length).
 *
 * @note Buffer for the NFC RX/TX data is used by EasyDMA and must be located in RAM.
 *
 * @param[in] p_reg        Pointer to the structure of registers of the peripheral.
 * @param[in] p_rxtx_buf   Pointer to the receive or transmit buffer.
 * @param[in] max_txrx_len Maximum receive or transmit length in bytes
 *                         (size of the RAM buffer for EasyDMA).
 * @param[in] rx           True if buffer is set for the frame reception, false if buffer is set for
 *                         the frame transmission.
 */
NRFY_STATIC_INLINE void nrfy_nfct_rxtx_buffer_set(NRF_NFCT_Type * p_reg,
                                                  uint8_t *       p_rxtx_buf,
                                                  uint16_t        max_txrx_len,
                                                  bool            rx)
{
    if (p_rxtx_buf && !rx)
    {
        NRFY_CACHE_WB(p_rxtx_buf, max_txrx_len);
    }

    nrf_nfct_rxtx_buffer_set(p_reg, p_rxtx_buf, max_txrx_len);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_task_trigger} */
NRFY_STATIC_INLINE void nrfy_nfct_task_trigger(NRF_NFCT_Type * p_reg, nrf_nfct_task_t task)
{
    nrf_nfct_task_trigger(p_reg, task);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_task_address_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_task_address_get(NRF_NFCT_Type const * p_reg,
                                                       nrf_nfct_task_t       task)
{
    return nrf_nfct_task_address_get(p_reg, task);
}

/** @refhal{nrf_nfct_event_clear} */
NRFY_STATIC_INLINE void nrfy_nfct_event_clear(NRF_NFCT_Type * p_reg, nrf_nfct_event_t event)
{
    nrf_nfct_event_clear(p_reg, event);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_event_check} */
NRFY_STATIC_INLINE bool nrfy_nfct_event_check(NRF_NFCT_Type const * p_reg, nrf_nfct_event_t event)
{
    nrf_barrier_rw();
    bool check = nrf_nfct_event_check(p_reg, event);
    nrf_barrier_r();
    return check;
}

/** @refhal{nrf_nfct_shorts_enable} */
NRFY_STATIC_INLINE void nrfy_nfct_shorts_enable(NRF_NFCT_Type * p_reg, uint32_t short_mask)
{
    nrf_nfct_shorts_enable(p_reg, short_mask);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_shorts_disable} */
NRFY_STATIC_INLINE void nrfy_nfct_shorts_disable(NRF_NFCT_Type * p_reg, uint32_t short_mask)
{
    nrf_nfct_shorts_disable(p_reg, short_mask);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_shorts_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_shorts_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint32_t shorts = nrf_nfct_shorts_get(p_reg);
    nrf_barrier_r();
    return shorts;
}

/** @refhal{nrf_nfct_shorts_set} */
NRFY_STATIC_INLINE void nrfy_nfct_shorts_set(NRF_NFCT_Type * p_reg, uint32_t short_mask)
{
    nrf_nfct_shorts_set(p_reg, short_mask);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_int_enable} */
NRFY_STATIC_INLINE void nrfy_nfct_int_enable(NRF_NFCT_Type * p_reg, uint32_t mask)
{
    nrf_nfct_int_enable(p_reg, mask);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_int_enable_check} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_int_enable_check(NRF_NFCT_Type const * p_reg, uint32_t mask)
{
    nrf_barrier_rw();
    uint32_t check = nrf_nfct_int_enable_check(p_reg, mask);
    nrf_barrier_r();
    return check;
}

/** @refhal{nrf_nfct_int_enable_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_int_enable_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint32_t check = nrf_nfct_int_enable_get(p_reg);
    nrf_barrier_w();
    return check;
}

/** @refhal{nrf_nfct_int_disable} */
NRFY_STATIC_INLINE void nrfy_nfct_int_disable(NRF_NFCT_Type * p_reg, uint32_t mask)
{
    nrf_nfct_int_disable(p_reg, mask);
    nrf_barrier_w();
}

#if NRFY_NFCT_HAS_MODULATION_PSEL_REG
/** @refhal{nrf_nfct_mod_ctrl_pin_set} */
NRFY_STATIC_INLINE void nrfy_nfct_mod_ctrl_pin_set(NRF_NFCT_Type * p_reg, uint32_t mod_ctrl_pin)
{
    nrf_nfct_mod_ctrl_pin_set(p_reg, mod_ctrl_pin);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_mod_ctrl_pin_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_mod_ctrl_pin_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint32_t pins = nrf_nfct_mod_ctrl_pin_get(p_reg);
    nrf_barrier_r();
    return pins;
}
#endif // NRFY_NFCT_HAS_MODULATION_PSEL_REG

/** @refhal{nrf_nfct_modulation_output_set} */
#if NRFY_NFCT_HAS_MODULATION_CTRL_REG
NRFY_STATIC_INLINE void nrfy_nfct_modulation_output_set(NRF_NFCT_Type *            p_reg,
                                                        nrf_nfct_modulation_ctrl_t mod_ctrl)
{
    nrf_nfct_modulation_output_set(p_reg, mod_ctrl);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_modulation_output_get} */
NRFY_STATIC_INLINE
nrf_nfct_modulation_ctrl_t nrfy_nfct_modulation_output_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    nrf_nfct_modulation_ctrl_t modulation_ctrl = nrf_nfct_modulation_output_get(p_reg);
    nrf_barrier_r();
    return modulation_ctrl;
}
#endif // NRFY_NFCT_HAS_MODULATION_CTRL_REG

/** @refhal{nrf_nfct_error_status_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_error_status_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint32_t error_status = nrf_nfct_error_status_get(p_reg);
    nrf_barrier_r();
    return error_status;
}

/** @refhal{nrf_nfct_error_status_clear} */
NRFY_STATIC_INLINE void nrfy_nfct_error_status_clear(NRF_NFCT_Type * p_reg, uint32_t error_flag)
{
    nrf_nfct_error_status_clear(p_reg, error_flag);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_rx_frame_status_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_rx_frame_status_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint32_t frame_status = nrf_nfct_rx_frame_status_get(p_reg);
    nrf_barrier_r();
    return frame_status;
}

/** @refhal{nrf_nfct_rx_frame_status_clear} */
NRFY_STATIC_INLINE void nrfy_nfct_rx_frame_status_clear(NRF_NFCT_Type * p_reg,
                                                        uint32_t        framestatus_flags)
{
    nrf_nfct_rx_frame_status_clear(p_reg, framestatus_flags);
    nrf_barrier_w();
}

#if NRFY_NFCT_HAS_TAG_STATE_REG
/** @refhal{nrf_nfct_tag_state_get} */
NRFY_STATIC_INLINE nrf_nfct_tag_state_t nrfy_nfct_tag_state_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_r();
    nrf_nfct_tag_state_t tag_state = nrf_nfct_tag_state_get(p_reg);
    nrf_barrier_r();
    return tag_state;
}
#endif // NRFY_NFCT_HAS_TAG_STATE_REG

#if NRFY_NFCT_HAS_SLEEP_STATE_REG
/** @refhal{nrf_nfct_sleep_state_get} */
NRFY_STATIC_INLINE nrf_nfct_sleep_state_t nrfy_nfct_sleep_state_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_r();
    nrf_nfct_sleep_state_t sleep_state = nrf_nfct_sleep_state_get(p_reg);
    nrf_barrier_r();
    return sleep_state;
}
#endif // NRFY_NFCT_HAS_SLEEP_STATE_REG

/** @refhal{nrf_nfct_field_status_get} */
NRFY_STATIC_INLINE uint8_t nrfy_nfct_field_status_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_r();
    uint8_t status = nrf_nfct_field_status_get(p_reg);
    nrf_barrier_r();
    return status;
}

/** @refhal{nrf_nfct_frame_delay_min_get} */
NRFY_STATIC_INLINE uint16_t nrfy_nfct_frame_delay_min_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint16_t frame_delay_min = nrf_nfct_frame_delay_min_get(p_reg);
    nrf_barrier_r();
    return frame_delay_min;
}

/** @refhal{nrf_nfct_frame_delay_min_set} */
NRFY_STATIC_INLINE void nrfy_nfct_frame_delay_min_set(NRF_NFCT_Type * p_reg,
                                                      uint16_t        frame_delay_min)
{
    nrf_nfct_frame_delay_min_set(p_reg, frame_delay_min);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_frame_delay_max_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_frame_delay_max_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint32_t frame_delay_max = nrf_nfct_frame_delay_max_get(p_reg);
    nrf_barrier_r();
    return frame_delay_max;
}

/** @refhal{nrf_nfct_frame_delay_max_set} */
NRFY_STATIC_INLINE void nrfy_nfct_frame_delay_max_set(NRF_NFCT_Type * p_reg,
                                                      uint32_t        frame_delay_max)
{
    nrf_nfct_frame_delay_max_set(p_reg, frame_delay_max);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_frame_delay_mode_get} */
NRFY_STATIC_INLINE
nrf_nfct_frame_delay_mode_t nrfy_nfct_frame_delay_mode_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    nrf_nfct_frame_delay_mode_t frame_delay_mode = nrf_nfct_frame_delay_mode_get(p_reg);
    nrf_barrier_r();
    return frame_delay_mode;
}

/** @refhal{nrf_nfct_frame_delay_mode_set} */
NRFY_STATIC_INLINE void nrfy_nfct_frame_delay_mode_set(NRF_NFCT_Type *             p_reg,
                                                       nrf_nfct_frame_delay_mode_t frame_delay_mode)
{
    nrf_nfct_frame_delay_mode_set(p_reg, frame_delay_mode);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_rxtx_buffer_get} */
NRFY_STATIC_INLINE uint8_t * nrfy_nfct_rxtx_buffer_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint8_t *buffer = nrf_nfct_rxtx_buffer_get(p_reg);
    nrf_barrier_r();
    return buffer;
}

/** @refhal{nrf_nfct_max_rxtx_length_get} */
NRFY_STATIC_INLINE uint16_t nrfy_nfct_max_rxtx_length_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint16_t max_length = nrf_nfct_max_rxtx_length_get(p_reg);
    nrf_barrier_r();
    return max_length;
}

/** @refhal{nrf_nfct_tx_frame_config_get} */
NRFY_STATIC_INLINE uint8_t nrfy_nfct_tx_frame_config_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint8_t frame_config = nrf_nfct_tx_frame_config_get(p_reg);
    nrf_barrier_r();
    return frame_config;
}

/** @refhal{nrf_nfct_tx_frame_config_set} */
NRFY_STATIC_INLINE void nrfy_nfct_tx_frame_config_set(NRF_NFCT_Type * p_reg, uint8_t flags)
{
    nrf_nfct_rx_frame_config_set(p_reg, flags);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_tx_bits_get} */
NRFY_STATIC_INLINE uint16_t nrfy_nfct_tx_bits_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint16_t bits = nrf_nfct_tx_bits_get(p_reg);
    nrf_barrier_r();
    return bits;
}

/** @refhal{nrf_nfct_tx_bits_set} */
NRFY_STATIC_INLINE void nrfy_nfct_tx_bits_set(NRF_NFCT_Type * p_reg, uint16_t tx_bits)
{
    nrf_nfct_tx_bits_set(p_reg, tx_bits);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_rx_frame_config_get} */
NRFY_STATIC_INLINE uint8_t nrfy_nfct_rx_frame_config_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint8_t frame_config = nrf_nfct_rx_frame_config_get(p_reg);
    nrf_barrier_r();
    return frame_config;
}

/** @refhal{nrf_nfct_rx_frame_config_set} */
NRFY_STATIC_INLINE void nrfy_nfct_rx_frame_config_set(NRF_NFCT_Type * p_reg, uint8_t flags)
{
    nrf_nfct_rx_frame_config_set(p_reg, flags);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_rx_bits_get} */
NRFY_STATIC_INLINE uint16_t nrfy_nfct_rx_bits_get(NRF_NFCT_Type const * p_reg, bool crc_excluded)
{
    nrf_barrier_r();
    uint16_t rx_bits = nrf_nfct_rx_bits_get(p_reg, crc_excluded);
    nrf_barrier_r();
    return rx_bits;
}

/** @refhal{nrf_nfct_nfcid1_get} */
NRFY_STATIC_INLINE
nrf_nfct_sensres_nfcid1_size_t nrfy_nfct_nfcid1_get(NRF_NFCT_Type const * p_reg,
                                                    uint8_t *             p_nfcid1_buf)
{
    nrf_barrier_rw();
    nrf_nfct_sensres_nfcid1_size_t nfcid1_size = nrf_nfct_nfcid1_get(p_reg, p_nfcid1_buf);
    nrf_barrier_rw();
    return nfcid1_size;
}

/** @refhal{nrf_nfct_nfcid1_set} */
NRFY_STATIC_INLINE void nrfy_nfct_nfcid1_set(NRF_NFCT_Type *                p_reg,
                                             uint8_t const *                p_nfcid1_buf,
                                             nrf_nfct_sensres_nfcid1_size_t nfcid1_size)
{
    nrf_nfct_nfcid1_set(p_reg, p_nfcid1_buf, nfcid1_size);
    nrf_barrier_w();
}

#if NRFY_NFCT_HAS_AUTOCOLRES_CONFIG_REG
/** @refhal{nrf_nfct_autocolres_is_enabled} */
NRFY_STATIC_INLINE bool nrfy_nfct_autocolres_is_enabled(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    bool enabled = nrf_nfct_autocolres_is_enabled(p_reg);
    nrf_barrier_r();
    return enabled;
}

/** @refhal{nrf_nfct_autocolres_enable} */
NRFY_STATIC_INLINE void nrfy_nfct_autocolres_enable(NRF_NFCT_Type * p_reg)
{
    nrf_nfct_autocolres_enable(p_reg);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_autocolres_disable} */
NRFY_STATIC_INLINE void nrfy_nfct_autocolres_disable(NRF_NFCT_Type * p_reg)
{
    nrf_nfct_autocolres_disable(p_reg);
    nrf_barrier_w();
}
#endif // NRFY_NFCT_HAS_AUTOCOLRES_CONFIG_REG

/** @refhal{nrf_nfct_sensres_nfcid1_size_get} */
NRFY_STATIC_INLINE
nrf_nfct_sensres_nfcid1_size_t nrfy_nfct_sensres_nfcid1_size_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    nrf_nfct_sensres_nfcid1_size_t nfcid1_size = nrf_nfct_sensres_nfcid1_size_get(p_reg);
    nrf_barrier_r();
    return nfcid1_size;
}

/** @refhal{nrf_nfct_sensres_nfcid1_size_set} */
NRFY_STATIC_INLINE
void nrfy_nfct_sensres_nfcid1_size_set(NRF_NFCT_Type *                p_reg,
                                       nrf_nfct_sensres_nfcid1_size_t nfcid1_size)
{
    nrf_nfct_sensres_nfcid1_size_set(p_reg, nfcid1_size);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_sensres_bit_frame_sdd_get} */
NRFY_STATIC_INLINE
nrf_nfct_sensres_bit_frame_sdd_t nrfy_nfct_sensres_bit_frame_sdd_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    nrf_nfct_sensres_bit_frame_sdd_t frame_sdd = nrf_nfct_sensres_bit_frame_sdd_get(p_reg);
    nrf_barrier_r();
    return frame_sdd;
}

/** @refhal{nrf_nfct_sensres_bit_frame_sdd_set} */
NRFY_STATIC_INLINE
void nrfy_nfct_sensres_bit_frame_sdd_set(NRF_NFCT_Type *                  p_reg,
                                         nrf_nfct_sensres_bit_frame_sdd_t bit_frame_sdd)
{
    nrf_nfct_sensres_bit_frame_sdd_set(p_reg, bit_frame_sdd);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_sensres_platform_config_get} */
NRFY_STATIC_INLINE nrf_nfct_sensres_platform_config_t
nrfy_nfct_sensres_platform_config_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    nrf_nfct_sensres_platform_config_t config = nrf_nfct_sensres_platform_config_get(p_reg);
    nrf_barrier_r();
    return config;
}

/** @refhal{nrf_nfct_sensres_platform_config_set} */
NRFY_STATIC_INLINE
void nrfy_nfct_sensres_platform_config_set(NRF_NFCT_Type *                    p_reg,
                                           nrf_nfct_sensres_platform_config_t platform_config)
{
    nrf_nfct_sensres_platform_config_set(p_reg, platform_config);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_selres_cascade_check} */
NRFY_STATIC_INLINE bool nrfy_nfct_selres_cascade_check(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    bool check = nrf_nfct_selres_cascade_check(p_reg);
    nrf_barrier_r();
    return check;
}

/** @refhal{nrf_nfct_selres_protocol_get} */
NRFY_STATIC_INLINE
nrf_nfct_selres_protocol_t nrfy_nfct_selres_protocol_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    nrf_nfct_selres_protocol_t protocol = nrf_nfct_selres_protocol_get(p_reg);
    nrf_barrier_r();
    return protocol;
}

/** @refhal{nrf_nfct_selres_protocol_set} */
NRFY_STATIC_INLINE void nrfy_nfct_selres_protocol_set(NRF_NFCT_Type *            p_reg,
                                                      nrf_nfct_selres_protocol_t sel_res_protocol)
{
    nrf_nfct_selres_protocol_set(p_reg, sel_res_protocol);
    nrf_barrier_w();
}

/** @refhal{nrf_nfct_selres_get} */
NRFY_STATIC_INLINE uint32_t nrfy_nfct_selres_get(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    uint32_t selres = nrf_nfct_selres_get(p_reg);
    nrf_barrier_r();
    return selres;
}

/** @refhal{nrf_nfct_selres_set} */
NRFY_STATIC_INLINE void nrfy_nfct_selres_set(NRF_NFCT_Type * p_reg, uint32_t selres)
{
    nrf_nfct_selres_set(p_reg, selres);
    nrf_barrier_w();
}

#if NRFY_NFCT_HAS_PAD_CONFIG_REG
/** @refhal{nrf_nfct_pad_config_enable_check} */
NRFY_STATIC_INLINE bool nrfy_nfct_pad_config_enable_check(NRF_NFCT_Type const * p_reg)
{
    nrf_barrier_rw();
    bool enabled = nrf_nfct_pad_config_enable_check(p_reg);
    nrf_barrier_w();
    return enabled;
}

/** @refhal{nrf_nfct_pad_config_enable_set} */
NRFY_STATIC_INLINE void nrfy_nfct_pad_config_enable_set(NRF_NFCT_Type * p_reg, bool enable)
{
    nrf_nfct_pad_config_enable_set(p_reg, enable);
    nrf_barrier_w();
}
#endif // NRFY_NFCT_HAS_PAD_CONFIG_REG

#if NRFY_NFCT_HAS_BIAS_CONFIG_TRIM_REG
/** @refhal{nrf_nfct_bias_config_get} */
NRFY_STATIC_INLINE void nrfy_nfct_bias_config_get(NRF_NFCT_Type const *    p_reg,
                                                  nrf_nfct_bias_config_t * p_bias_config)
{
    nrf_barrier_rw();
    nrf_nfct_bias_config_get(p_reg, p_bias_config);
    nrf_barrier_r();
}

/** @refhal{nrf_nfct_bias_config_set} */
NRFY_STATIC_INLINE void nrfy_nfct_bias_config_set(NRF_NFCT_Type *                p_reg,
                                                  nrf_nfct_bias_config_t const * p_bias_config)
{
    nrf_nfct_bias_config_set(p_reg, p_bias_config);
    nrf_barrier_w();
}
#endif // NRFY_NFCT_HAS_BIAS_CONFIG_TRIM_REG

/** @} */

NRFY_STATIC_INLINE void __nrfy_internal_nfct_event_enabled_clear(NRF_NFCT_Type *  p_reg,
                                                                 uint32_t         mask,
                                                                 nrf_nfct_event_t event)
{
    if (mask & NRFY_EVENT_TO_INT_BITMASK(event))
    {
        nrf_nfct_event_clear(p_reg, event);
    }
}

NRFY_STATIC_INLINE bool __nrfy_internal_nfct_event_handle(NRF_NFCT_Type  * p_reg,
                                                          uint32_t         mask,
                                                          nrf_nfct_event_t event,
                                                          uint32_t       * p_evt_mask)
{
    if ((mask & NRFY_EVENT_TO_INT_BITMASK(event)) && nrf_nfct_event_check(p_reg, event))
    {
        nrf_nfct_event_clear(p_reg, event);
        if (p_evt_mask)
        {
            *p_evt_mask |= NRFY_EVENT_TO_INT_BITMASK(event);
        }
        return true;
    }

    return false;
}

NRFY_STATIC_INLINE uint32_t __nrfy_internal_nfct_events_process(NRF_NFCT_Type * p_reg, uint32_t mask)
{
    uint32_t evt_mask = 0;

    nrf_barrier_r();
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_READY, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_FIELDDETECTED, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_FIELDLOST, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_TXFRAMESTART, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_TXFRAMEEND, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_RXFRAMESTART, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_RXFRAMEEND, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_ERROR, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_RXERROR, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_ENDRX, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_ENDTX, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_AUTOCOLRESSTARTED, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_COLLISION, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_SELECTED, &evt_mask);
    __nrfy_internal_nfct_event_handle(p_reg, mask, NRF_NFCT_EVENT_STARTED, &evt_mask);

    if (evt_mask & NRFY_EVENT_TO_INT_BITMASK(NRF_NFCT_EVENT_RXFRAMEEND))
    {
        uint8_t *buffer = nrf_nfct_rxtx_buffer_get(p_reg);
        uint16_t bytes = (nrf_nfct_rx_bits_get(p_reg, true) >> 3U);

        nrf_barrier_rw();
        NRFY_CACHE_INV(buffer, bytes);
    }

    nrf_barrier_w();

    return evt_mask;
}

#ifdef __cplusplus
}
#endif

#endif // NRFY_NFCT_H__