You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by st...@apache.org on 2016/07/27 23:13:57 UTC
[28/51] [partial] incubator-mynewt-core git commit: add stm32 and
nordic sdks based on new structure
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f06c2d2b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis.h
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis.h b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis.h
new file mode 100644
index 0000000..08ac9c2
--- /dev/null
+++ b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis.h
@@ -0,0 +1,398 @@
+/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
+ *
+ * The information contained herein is property of Nordic Semiconductor ASA.
+ * Terms and conditions of usage are described in detail in NORDIC
+ * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
+ *
+ * Licensees are granted free, non-transferable use of the information. NO
+ * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
+ * the file.
+ *
+ */
+#ifndef NRF_DRV_TWIS_H__
+#define NRF_DRV_TWIS_H__
+
+#include "nrf_drv_config.h"
+#include "nrf_drv_common.h"
+#include "sdk_errors.h"
+#include "nrf_twis.h"
+#include <stdint.h>
+#include "app_util.h"
+/**
+ * @ingroup nrf_twi
+ * @defgroup nrf_twis TWI slave HAL and driver
+ * @brief @tagAPI52 TWI slave APIs.
+ * @details The TWIS HAL provides basic APIs for accessing the registers of the TWIS.
+ * The TWIS driver provides APIs on a higher level.
+ */
+
+/**
+ * @ingroup nrf_twis
+ * @defgroup nrf_twis_drv TWI slave with EasyDMA driver
+ *
+ * @brief @tagAPI52 TWI slave with EasyDMA driver.
+ * @{
+ */
+
+/**
+ * @defgroup nrf_twis_drv_config TWIS driver global configuration
+ *
+ * @brief This configuration is placed in the global configuration file @c nrf_drv_config.h.
+ * @{
+ */
+
+ /**
+ * @def TWIS_ASSUME_INIT_AFTER_RESET_ONLY
+ * @brief Assume that any instance would be initialized only once
+ *
+ * Optimization flag.
+ * Registers used by TWIS are shared by other peripherals.
+ * Normally, during initialization driver tries to clear all registers to known state before
+ * doing the initialization itself.
+ * This gives initialization safe procedure, no matter when it would be called.
+ * If you activate TWIS only once and do never uninitialize it - set this flag to 1 what gives
+ * more optimal code.
+ */
+
+ /**
+ * @def TWIS_NO_SYNC_MODE
+ * @brief Remove support for synchronous mode
+ *
+ * Synchronous mode would be used in specific situations.
+ * And it uses some additional code and data memory to safely process state machine
+ * by polling it in status functions.
+ * If this functionality is not required it may be disabled to free some resources.
+ */
+/** @} */
+
+/**
+ * @brief Event callback function event definitions.
+ */
+typedef enum
+{
+ TWIS_EVT_READ_REQ, ///< Read request detected
+ /**< If there is no buffer prepared, buf_req flag in the even will be set.
+ Call then @ref nrf_drv_twis_tx_prepare to give parameters for buffer.
+ */
+ TWIS_EVT_READ_DONE, ///< Read request has finished - free any data
+ TWIS_EVT_READ_ERROR, ///< Read request finished with error
+ TWIS_EVT_WRITE_REQ, ///< Write request detected
+ /**< If there is no buffer prepared, buf_req flag in the even will be set.
+ Call then @ref nrf_drv_twis_rx_prepare to give parameters for buffer.
+ */
+ TWIS_EVT_WRITE_DONE, ///< Write request has finished - process data
+ TWIS_EVT_WRITE_ERROR, ///< Write request finished with error
+ TWIS_EVT_GENERAL_ERROR ///< Error that happens not inside WRITE or READ transaction
+} nrf_drv_twis_evt_type_t;
+
+/**
+ * @brief TWIS driver instance structure
+ *
+ * @note We only need instance number here so we could really use just a number
+ * that would be send to every driver function.
+ * But for compatibility reason this number is inserted into the structure.
+ */
+typedef struct
+{
+ uint8_t instNr; /**< Instance number */
+}nrf_drv_twis_t;
+
+/**
+ * @brief TWIS driver event structure
+ */
+typedef struct
+{
+ nrf_drv_twis_evt_type_t type; ///< Event type
+ union
+ {
+ bool buf_req; ///< Flag for @ref TWIS_EVT_READ_REQ and @ref TWIS_EVT_WRITE_REQ
+ /**< Information if transmission buffer requires to be prepared */
+ uint32_t tx_amount; ///< Data for @ref TWIS_EVT_READ_DONE
+ uint32_t rx_amount; ///< Data for @ref TWIS_EVT_WRITE_DONE
+ uint32_t error; ///< Data for @ref TWIS_EVT_GENERAL_ERROR
+ }data;
+}nrf_drv_twis_evt_t;
+
+/**
+ * @brief TWI slave event callback function type.
+ *
+ * @param[in] p_event Event information structure.
+ */
+typedef void (*nrf_drv_twis_event_handler_t)(nrf_drv_twis_evt_t const * const p_event);
+
+/**
+ * @brief Structure for TWIS configuration
+ */
+typedef struct
+{
+ uint32_t addr[2]; //!< Set addresses that this slave should respond. Set 0 to disable.
+ uint32_t scl; //!< SCL pin number
+ uint32_t sda; //!< SDA pin number
+ uint8_t interrupt_priority; //!< The priority of interrupt for the module to set
+}nrf_drv_twis_config_t;
+
+/**
+ * @brief Possible error sources
+ *
+ * This is flag enum - values from this enum can be connected using logical or operator.
+ * @note
+ * We could use directly @ref nrf_twis_error_t. Error type enum is redefined here becouse
+ * of possible future extension (eg. supporting timeouts and synchronous mode).
+ */
+typedef enum
+{
+ NRF_DRV_TWIS_ERROR_OVERFLOW = NRF_TWIS_ERROR_OVERFLOW, /**< RX buffer overflow detected, and prevented */
+ NRF_DRV_TWIS_ERROR_DATA_NACK = NRF_TWIS_ERROR_DATA_NACK, /**< NACK sent after receiving a data byte */
+ NRF_DRV_TWIS_ERROR_OVERREAD = NRF_TWIS_ERROR_OVERREAD, /**< TX buffer over-read detected, and prevented */
+ NRF_DRV_TWIS_ERROR_UNEXPECTED_EVENT = 1 << 8 /**< Unexpected event detected by state machine */
+}nrf_drv_twis_error_t;
+
+/**
+ * @internal
+ * @brief Internal macro for creating TWIS driver instance
+ *
+ * Second level of indirection in creating the instance.
+ * Do not use this macro directly.
+ * Use @ref NRF_DRV_TWIS_INSTANCE instead.
+ */
+#define NRF_DRV_TWIS_INSTANCE_x(id) \
+ { \
+ TWIS##id##_INSTANCE_INDEX \
+ }
+
+/**
+ * @brief Macro for creating TWIS driver instance
+ *
+ * @param[in] id Instance index. Use 0 for TWIS0 and 1 for TWIS1
+ */
+#define NRF_DRV_TWIS_INSTANCE(id) NRF_DRV_TWIS_INSTANCE_x(id)
+
+/**
+ * @internal
+ * @brief Internal macro for creating TWIS driver default configuration
+ *
+ * Second level of indirection in creating the instance.
+ * Do not use this macro directly.
+ * Use @ref NRF_DRV_TWIS_SLAVE_DEFAULT_CONFIG instead.
+ */
+#define NRF_DRV_TWIS_DEFAULT_CONFIG_x(id) \
+{ \
+ .addr = { TWIS##id##_CONFIG_ADDR0, TWIS##id##_CONFIG_ADDR1 }, \
+ .scl = TWIS##id##_CONFIG_SCL, \
+ .sda = TWIS##id##_CONFIG_SDA, \
+ .interrupt_priority = TWIS##id##_CONFIG_IRQ_PRIORITY \
+}
+
+/**
+ * @brief Generate default configuration for TWIS driver instance
+ *
+ * @param[in] id Instance index. Use 0 for TWIS0 and 1 for TWIS1
+ */
+#define NRF_DRV_TWIS_DEFAULT_CONFIG(id) NRF_DRV_TWIS_DEFAULT_CONFIG_x(id)
+
+/**
+ * @brief Function for initializing the TWIS driver instance.
+ *
+ * Function initializes and enables TWIS driver.
+ * @attention After driver initialization enable it by @ref nrf_drv_twis_enable
+ *
+ * @param[in] p_inst TWIS driver instance.
+ * @attention @em p_inst has to be global object.
+ * It would be used by interrupts so make it sure that object
+ * would not be destroyed when function is leaving.
+ * @param[in] p_config Initial configuration. If NULL, the default configuration is used.
+ * @param[in] event_handler Event handler provided by the user.
+ *
+ * @retval NRF_SUCCESS If initialization was successful.
+ * @retval NRF_ERROR_INVALID_STATE If the driver is already initialized.
+ * @retval NRF_ERROR_BUSY If some other peripheral with the same
+ * instance ID is already in use. This is
+ * possible only if PERIPHERAL_RESOURCE_SHARING_ENABLED
+ * is set to a value other than zero.
+ */
+ret_code_t nrf_drv_twis_init(
+ nrf_drv_twis_t const * const p_inst,
+ nrf_drv_twis_config_t const * p_config,
+ nrf_drv_twis_event_handler_t const event_handler);
+
+/**
+ * @brief Function for uninitializing the TWIS driver instance.
+ *
+ * Function initializes the peripheral and resets all registers to default values.
+ *
+ * @param[in] p_inst TWIS driver instance to uninitialize.
+ * @note
+ * It is safe to call nrf_drv_twis_uninit even before initialization.
+ * Actually @ref nrf_drv_twis_init function calls this function to
+ * make sure that TWIS state is known.
+ * @note
+ * If TWIS driver was in uninitialized state before calling this function,
+ * selected pins would not be reset to default configuration.
+ */
+void nrf_drv_twis_uninit(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Enable TWIS instance
+ *
+ * This function enables TWIS instance.
+ * Function defined if there is needs for dynamically enabling and disabling the peripheral.
+ * Use @ref nrf_drv_twis_enable and @ref nrf_drv_twis_disable functions.
+ * They do not change any configuration registers.
+ *
+ * @param p_inst TWIS driver instance.
+ */
+void nrf_drv_twis_enable(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Disable TWIS instance
+ *
+ * Disabling TWIS instance gives possibility to turn off the TWIS while
+ * holding configuration done by @ref nrf_drv_twis_init
+ *
+ * @param p_inst TWIS driver instance.
+ */
+void nrf_drv_twis_disable(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Get and clear last error flags
+ *
+ * Function gets information about errors.
+ * This is also the only possibility to exit from error substate of the internal state machine.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ * @return Error flags defined in @ref nrf_drv_twis_error_t
+ * @attention
+ * This function clears error state and flags.
+ */
+uint32_t nrf_drv_twis_error_get_and_clear(nrf_drv_twis_t const * const p_inst);
+
+
+/**
+ * @brief Prepare data for sending
+ *
+ * This function should be used in response for @ref TWIS_EVT_READ_REQ event.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ * @param[in] p_buf Transmission buffer
+ * @attention Transmission buffer has to be placed in RAM.
+ * @param size Maximum number of bytes that master may read from buffer given.
+ *
+ * @retval NRF_SUCCESS Preparation finished properly
+ * @retval NRF_ERROR_INVALID_ADDR Given @em p_buf is not placed inside the RAM
+ * @retval NRF_ERROR_INVALID_LENGTH Wrong value in @em size parameter
+ * @retval NRF_ERROR_INVALID_STATE Module not initialized or not enabled
+ */
+ret_code_t nrf_drv_twis_tx_prepare(
+ nrf_drv_twis_t const * const p_inst,
+ void const * const p_buf,
+ size_t size);
+
+/**
+ * @brief Get number of transmitted bytes
+ *
+ * Function returns number of bytes sent.
+ * This function may be called after @ref TWIS_EVT_READ_DONE or @ref TWIS_EVT_READ_ERROR events.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ *
+ * @return Number of bytes sent.
+ */
+size_t nrf_drv_twis_tx_amount(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Prepare data for receiving
+ *
+ * This function should be used in response for @ref TWIS_EVT_WRITE_REQ event.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ * @param[in] p_buf Buffer that would be filled with received data
+ * @attention Receiving buffer has to be placed in RAM.
+ * @param size Size of the buffer (maximum amount of data to receive)
+ *
+ * @retval NRF_SUCCESS Preparation finished properly
+ * @retval NRF_ERROR_INVALID_ADDR Given @em p_buf is not placed inside the RAM
+ * @retval NRF_ERROR_INVALID_LENGTH Wrong value in @em size parameter
+ * @retval NRF_ERROR_INVALID_STATE Module not initialized or not enabled
+ */
+ret_code_t nrf_drv_twis_rx_prepare(
+ nrf_drv_twis_t const * const p_inst,
+ void * const p_buf,
+ size_t size);
+
+/**
+ * @brief Get number of received bytes
+ *
+ * Function returns number of bytes received.
+ * This function may be called after @ref TWIS_EVT_WRITE_DONE or @ref TWIS_EVT_WRITE_ERROR events.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ *
+ * @return Number of bytes received.
+ */
+size_t nrf_drv_twis_rx_amount(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Function checks if driver is busy right now
+ *
+ * Actual driver substate is tested.
+ * If driver is in any other state than IDLE or ERROR this function returns true.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ *
+ * @retval true Driver is in state other than ERROR or IDLE
+ * @retval false There is no transmission pending.
+ */
+bool nrf_drv_twis_is_busy(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Function checks if driver is waiting for tx buffer
+ *
+ * If this function returns true, it means that driver is stalled expecting
+ * of the @ref nrf_drv_twis_tx_prepare function call.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ *
+ * @retval true Driver waits for @ref nrf_drv_twis_tx_prepare
+ * @retval false Driver is not in the state where it waits for preparing tx buffer.
+ */
+bool nrf_drv_twis_is_waiting_tx_buff(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Function checks if driver is waiting for rx buffer
+ *
+ * If this function returns true, it means that driver is staled expecting
+ * of the @ref nrf_drv_twis_rx_prepare function call.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ *
+ * @retval true Driver waits for @ref nrf_drv_twis_rx_prepare
+ * @retval false Driver is not in the state where it waits for preparing rx buffer.
+ */
+bool nrf_drv_twis_is_waiting_rx_buff(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Check if driver is sending data
+ *
+ * If this function returns true, it means that there is ongoing output transmission.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ *
+ * @retval true There is ongoing output transmission.
+ * @retval false Driver is in other state.
+ */
+bool nrf_drv_twis_is_pending_tx(nrf_drv_twis_t const * const p_inst);
+
+/**
+ * @brief Check if driver is receiving data
+ *
+ * If this function returns true, it means that there is ongoing input transmission.
+ *
+ * @param[in] p_inst TWIS driver instance.
+ *
+ * @retval true There is ongoing input transmission.
+ * @retval false Driver is in other state.
+ */
+bool nrf_drv_twis_is_pending_rx(nrf_drv_twis_t const * const p_inst);
+
+/** @} */ /* End of lib_twis_drv group */
+#endif /* NRF_DRV_TWIS_H__ */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f06c2d2b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis_inst.def
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis_inst.def b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis_inst.def
new file mode 100644
index 0000000..c2f642a
--- /dev/null
+++ b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/twis_slave/nrf_drv_twis_inst.def
@@ -0,0 +1,20 @@
+/**
+ * @file
+ * @brief Xmacro file with contains enumeration of TWIS instances to implement
+ *
+ * Use this file everywhere where anything has to be generated for all active TWIS instances.
+ * Xmacro format:
+ *
+ * @code
+ X(n)
+ * @endcode
+ *
+ * Where @em n is number of the instance itself (0 for NRF_TWIS0).
+ */
+#if (TWIS0_ENABLED == 1)
+ X(0)
+#endif
+#if (TWIS1_ENABLED == 1)
+ X(1)
+#endif
+#undef X
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f06c2d2b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.c
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.c b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.c
new file mode 100644
index 0000000..845b919
--- /dev/null
+++ b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.c
@@ -0,0 +1,851 @@
+/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
+ *
+ * The information contained herein is property of Nordic Semiconductor ASA.
+ * Terms and conditions of usage are described in detail in NORDIC
+ * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
+ *
+ * Licensees are granted free, non-transferable use of the information. NO
+ * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
+ * the file.
+ *
+ */
+
+#include "nrf_drv_uart.h"
+#include "nrf_assert.h"
+#include "nordic_common.h"
+#include "nrf_drv_common.h"
+#include "nrf_gpio.h"
+#include "app_util_platform.h"
+
+// This set of macros makes it possible to exclude parts of code, when one type
+// of supported peripherals is not used.
+#ifdef NRF51
+#define UART_IN_USE
+#elif defined(NRF52)
+#if (UART_EASY_DMA_SUPPORT == 1)
+#define UARTE_IN_USE
+#endif
+#if (UART_LEGACY_SUPPORT == 1)
+#define UART_IN_USE
+#endif
+#endif
+
+
+#if (defined(UARTE_IN_USE) && defined(UART_IN_USE))
+ // UARTE and UART combined
+ #define CODE_FOR_UARTE(code) if (m_cb.use_easy_dma) { code }
+ #define CODE_FOR_UART(code) else { code }
+#elif (defined(UARTE_IN_USE) && !defined(UART_IN_USE))
+ // UARTE only
+ #define CODE_FOR_UARTE(code) { code }
+ #define CODE_FOR_UART(code)
+#elif (!defined(UARTE_IN_USE) && defined(UART_IN_USE))
+ // UART only
+ #define CODE_FOR_UARTE(code)
+ #define CODE_FOR_UART(code) { code }
+#else
+ #error "Wrong configuration."
+#endif
+
+#ifndef IS_EASY_DMA_RAM_ADDRESS
+ #define IS_EASY_DMA_RAM_ADDRESS(addr) (((uint32_t)addr & 0xFFFF0000) == 0x20000000)
+#endif
+
+#define TX_COUNTER_ABORT_REQ_VALUE 256
+
+typedef struct
+{
+ void * p_context;
+ nrf_uart_event_handler_t handler;
+ uint8_t const * p_tx_buffer;
+ uint8_t * p_rx_buffer;
+ uint8_t * p_rx_secondary_buffer;
+ volatile uint16_t tx_counter;
+ uint8_t tx_buffer_length;
+ uint8_t rx_buffer_length;
+ uint8_t rx_secondary_buffer_length;
+ volatile uint8_t rx_counter;
+ bool rx_enabled;
+ nrf_drv_state_t state;
+#if (defined(UARTE_IN_USE) && defined(UART_IN_USE))
+ bool use_easy_dma;
+#endif
+} uart_control_block_t;
+
+static uart_control_block_t m_cb;
+static const nrf_drv_uart_config_t m_default_config = NRF_DRV_UART_DEFAULT_CONFIG;
+
+__STATIC_INLINE void apply_config(nrf_drv_uart_config_t const * p_config)
+{
+ nrf_gpio_pin_set(p_config->pseltxd);
+ nrf_gpio_cfg_output(p_config->pseltxd);
+ nrf_gpio_cfg_input(p_config->pselrxd, NRF_GPIO_PIN_NOPULL);
+
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_baudrate_set(NRF_UARTE0, (nrf_uarte_baudrate_t)p_config->baudrate);
+ nrf_uarte_configure(NRF_UARTE0, (nrf_uarte_parity_t)p_config->parity,
+ (nrf_uarte_hwfc_t)p_config->hwfc);
+ nrf_uarte_txrx_pins_set(NRF_UARTE0, p_config->pseltxd, p_config->pselrxd);
+ if (p_config->hwfc == NRF_UART_HWFC_ENABLED)
+ {
+ nrf_gpio_cfg_input(p_config->pselcts, NRF_GPIO_PIN_NOPULL);
+ nrf_gpio_pin_set(p_config->pselrts);
+ nrf_gpio_cfg_output(p_config->pselrts);
+ nrf_uarte_hwfc_pins_set(NRF_UARTE0, p_config->pselrts, p_config->pselcts);
+ }
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_baudrate_set(NRF_UART0, p_config->baudrate);
+ nrf_uart_configure(NRF_UART0, p_config->parity, p_config->hwfc);
+ nrf_uart_txrx_pins_set(NRF_UART0, p_config->pseltxd, p_config->pselrxd);
+ if (p_config->hwfc == NRF_UART_HWFC_ENABLED)
+ {
+ nrf_gpio_cfg_input(p_config->pselcts, NRF_GPIO_PIN_NOPULL);
+ nrf_gpio_pin_set(p_config->pselrts);
+ nrf_gpio_cfg_output(p_config->pselrts);
+ nrf_uart_hwfc_pins_set(NRF_UART0, p_config->pselrts, p_config->pselcts);
+ }
+ )
+}
+
+__STATIC_INLINE void interrupts_enable(uint8_t interrupt_priority)
+{
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ENDRX);
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ENDTX);
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ERROR);
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_RXTO);
+ nrf_uarte_int_enable(NRF_UARTE0, NRF_UARTE_INT_ENDRX_MASK |
+ NRF_UARTE_INT_ENDTX_MASK |
+ NRF_UARTE_INT_ERROR_MASK |
+ NRF_UARTE_INT_RXTO_MASK);
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_TXDRDY);
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_RXTO);
+ nrf_uart_int_enable(NRF_UART0, NRF_UART_INT_MASK_TXDRDY |
+ NRF_UART_INT_MASK_RXTO);
+ )
+ nrf_drv_common_irq_enable(UART0_IRQn, interrupt_priority);
+}
+
+__STATIC_INLINE void interrupts_disable(void)
+{
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_int_disable(NRF_UARTE0, NRF_UARTE_INT_ENDRX_MASK |
+ NRF_UARTE_INT_ENDTX_MASK |
+ NRF_UARTE_INT_ERROR_MASK |
+ NRF_UARTE_INT_RXTO_MASK);
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_int_disable(NRF_UART0, NRF_UART_INT_MASK_RXDRDY |
+ NRF_UART_INT_MASK_TXDRDY |
+ NRF_UART_INT_MASK_ERROR |
+ NRF_UART_INT_MASK_RXTO);
+ )
+ nrf_drv_common_irq_disable(UART0_IRQn);
+}
+
+__STATIC_INLINE void pins_to_default(void)
+{
+ /* Reset pins to default states */
+ uint32_t txd;
+ uint32_t rxd;
+ uint32_t rts;
+ uint32_t cts;
+
+ CODE_FOR_UARTE
+ (
+ txd = nrf_uarte_tx_pin_get(NRF_UARTE0);
+ rxd = nrf_uarte_rx_pin_get(NRF_UARTE0);
+ rts = nrf_uarte_rts_pin_get(NRF_UARTE0);
+ cts = nrf_uarte_cts_pin_get(NRF_UARTE0);
+ nrf_uarte_txrx_pins_disconnect(NRF_UARTE0);
+ nrf_uarte_hwfc_pins_disconnect(NRF_UARTE0);
+ )
+ CODE_FOR_UART
+ (
+ txd = nrf_uart_tx_pin_get(NRF_UART0);
+ rxd = nrf_uart_rx_pin_get(NRF_UART0);
+ rts = nrf_uart_rts_pin_get(NRF_UART0);
+ cts = nrf_uart_cts_pin_get(NRF_UART0);
+ nrf_uart_txrx_pins_disconnect(NRF_UART0);
+ nrf_uart_hwfc_pins_disconnect(NRF_UART0);
+ )
+
+ nrf_gpio_cfg_default(txd);
+ nrf_gpio_cfg_default(rxd);
+
+ if (cts != NRF_UART_PSEL_DISCONNECTED)
+ {
+ nrf_gpio_cfg_default(cts);
+ }
+
+ if (rts != NRF_UART_PSEL_DISCONNECTED)
+ {
+ nrf_gpio_cfg_default(rts);
+ }
+
+}
+
+__STATIC_INLINE void uart_enable(void)
+{
+ CODE_FOR_UARTE(nrf_uarte_enable(NRF_UARTE0);)
+ CODE_FOR_UART(nrf_uart_enable(NRF_UART0););
+}
+
+__STATIC_INLINE void uart_disable(void)
+{
+ CODE_FOR_UARTE(nrf_uarte_disable(NRF_UARTE0);)
+ CODE_FOR_UART(nrf_uart_disable(NRF_UART0););
+}
+
+ret_code_t nrf_drv_uart_init(nrf_drv_uart_config_t const * p_config,
+ nrf_uart_event_handler_t event_handler)
+{
+ if (m_cb.state != NRF_DRV_STATE_UNINITIALIZED)
+ {
+ return NRF_ERROR_INVALID_STATE;
+ }
+
+ if (p_config == NULL)
+ {
+ p_config = &m_default_config;
+ }
+#if (defined(UARTE_IN_USE) && defined(UART_IN_USE))
+ m_cb.use_easy_dma = p_config->use_easy_dma;
+#endif
+ apply_config(p_config);
+
+ m_cb.handler = event_handler;
+ m_cb.p_context = p_config->p_context;
+
+ if (m_cb.handler)
+ {
+ interrupts_enable(p_config->interrupt_priority);
+ }
+
+ uart_enable();
+ m_cb.rx_buffer_length = 0;
+ m_cb.rx_secondary_buffer_length = 0;
+ m_cb.tx_buffer_length = 0;
+ m_cb.state = NRF_DRV_STATE_INITIALIZED;
+ m_cb.rx_enabled = false;
+ return NRF_SUCCESS;
+}
+
+void nrf_drv_uart_uninit(void)
+{
+ uart_disable();
+
+ if (m_cb.handler)
+ {
+ interrupts_disable();
+ }
+
+ pins_to_default();
+
+ m_cb.state = NRF_DRV_STATE_UNINITIALIZED;
+ m_cb.handler = NULL;
+}
+
+#if defined(UART_IN_USE)
+__STATIC_INLINE void tx_byte(void)
+{
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_TXDRDY);
+ uint8_t txd = m_cb.p_tx_buffer[m_cb.tx_counter];
+ m_cb.tx_counter++;
+ nrf_uart_txd_set(NRF_UART0, txd);
+}
+
+__STATIC_INLINE ret_code_t nrf_drv_uart_tx_for_uart()
+{
+ ret_code_t err_code = NRF_SUCCESS;
+
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_TXDRDY);
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STARTTX);
+
+ tx_byte();
+
+ if (m_cb.handler == NULL)
+ {
+ while (m_cb.tx_counter < (uint16_t) m_cb.tx_buffer_length)
+ {
+ while (!nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_TXDRDY) &&
+ m_cb.tx_counter != TX_COUNTER_ABORT_REQ_VALUE)
+ {
+ }
+ if (m_cb.tx_counter != TX_COUNTER_ABORT_REQ_VALUE)
+ {
+ tx_byte();
+ }
+ }
+
+ if (m_cb.tx_counter == TX_COUNTER_ABORT_REQ_VALUE)
+ {
+ err_code = NRF_ERROR_FORBIDDEN;
+ }
+ else
+ {
+ while (!nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_TXDRDY))
+ {
+ }
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STOPTX);
+ }
+ m_cb.tx_buffer_length = 0;
+ }
+
+ return err_code;
+}
+#endif
+
+#if defined(UARTE_IN_USE)
+__STATIC_INLINE ret_code_t nrf_drv_uart_tx_for_uarte()
+{
+ ret_code_t err_code = NRF_SUCCESS;
+
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ENDTX);
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_TXSTOPPED);
+ nrf_uarte_tx_buffer_set(NRF_UARTE0, m_cb.p_tx_buffer, m_cb.tx_buffer_length);
+ nrf_uarte_task_trigger(NRF_UARTE0, NRF_UARTE_TASK_STARTTX);
+
+ if (m_cb.handler == NULL)
+ {
+ bool endtx;
+ bool txstopped;
+ do
+ {
+ endtx = nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_ENDTX);
+ txstopped = nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_TXSTOPPED);
+ }
+ while ((!endtx) && (!txstopped));
+
+ if (txstopped)
+ {
+ err_code = NRF_ERROR_FORBIDDEN;
+ }
+ m_cb.tx_buffer_length = 0;
+ }
+
+ return err_code;
+}
+#endif
+
+ret_code_t nrf_drv_uart_tx(uint8_t const * const p_data, uint8_t length)
+{
+ ASSERT(m_cb.state == NRF_DRV_STATE_INITIALIZED);
+ ASSERT(length>0);
+ ASSERT(p_data);
+
+ CODE_FOR_UARTE
+ (
+ // EasyDMA requires that transfer buffers are placed in DataRAM,
+ // signal error if the are not.
+ if (!IS_EASY_DMA_RAM_ADDRESS(p_data))
+ {
+ return NRF_ERROR_INVALID_ADDR;
+ }
+ )
+
+ if (nrf_drv_uart_tx_in_progress())
+ {
+ return NRF_ERROR_BUSY;
+ }
+ m_cb.tx_buffer_length = length;
+ m_cb.p_tx_buffer = p_data;
+ m_cb.tx_counter = 0;
+
+ CODE_FOR_UARTE
+ (
+ return nrf_drv_uart_tx_for_uarte();
+ )
+ CODE_FOR_UART
+ (
+ return nrf_drv_uart_tx_for_uart();
+ )
+}
+
+bool nrf_drv_uart_tx_in_progress(void)
+{
+ return (m_cb.tx_buffer_length != 0);
+}
+
+#if defined(UART_IN_USE)
+__STATIC_INLINE void rx_enable(void)
+{
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_ERROR);
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_RXDRDY);
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STARTRX);
+}
+
+__STATIC_INLINE void rx_byte(void)
+{
+ if (!m_cb.rx_buffer_length)
+ {
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_RXDRDY);
+ // Byte received when buffer is not set - data lost.
+ (void) nrf_uart_rxd_get(NRF_UART0);
+ return;
+ }
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_RXDRDY);
+ m_cb.p_rx_buffer[m_cb.rx_counter] = nrf_uart_rxd_get(NRF_UART0);
+ m_cb.rx_counter++;
+}
+
+__STATIC_INLINE ret_code_t nrf_drv_uart_rx_for_uart(uint8_t * p_data, uint8_t length, bool second_buffer)
+{
+ if ((!m_cb.rx_enabled) && (!second_buffer))
+ {
+ rx_enable();
+ }
+ if (m_cb.handler == NULL)
+ {
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_RXTO);
+
+ bool rxrdy;
+ bool rxto;
+ bool error;
+ do
+ {
+ do
+ {
+ error = nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_ERROR);
+ rxrdy = nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_RXDRDY);
+ rxto = nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_RXTO);
+ } while ((!rxrdy) && (!rxto) && (!error));
+
+ if (error || rxto)
+ {
+ break;
+ }
+ rx_byte();
+ } while (m_cb.rx_buffer_length > m_cb.rx_counter);
+
+ m_cb.rx_buffer_length = 0;
+ if (error)
+ {
+ return NRF_ERROR_INTERNAL;
+ }
+
+ if (rxto)
+ {
+ return NRF_ERROR_FORBIDDEN;
+ }
+
+ if (m_cb.rx_enabled)
+ {
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STARTRX);
+ }
+ else
+ {
+ // Skip stopping RX if driver is forced to be enabled.
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STOPRX);
+ }
+ }
+ else
+ {
+ nrf_uart_int_enable(NRF_UART0, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+ }
+ return NRF_SUCCESS;
+}
+#endif
+
+#if defined(UARTE_IN_USE)
+__STATIC_INLINE ret_code_t nrf_drv_uart_rx_for_uarte(uint8_t * p_data, uint8_t length, bool second_buffer)
+{
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ENDRX);
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_RXTO);
+ nrf_uarte_rx_buffer_set(NRF_UARTE0, p_data, length);
+ if (!second_buffer)
+ {
+ nrf_uarte_task_trigger(NRF_UARTE0, NRF_UARTE_TASK_STARTRX);
+ }
+ else
+ {
+ nrf_uarte_shorts_enable(NRF_UARTE0, NRF_UARTE_SHORT_ENDRX_STARTRX);
+ }
+
+ if (m_cb.handler == NULL)
+ {
+ bool endrx;
+ bool rxto;
+ bool error;
+ do {
+ endrx = nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_ENDRX);
+ rxto = nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_RXTO);
+ error = nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_ERROR);
+ }while ((!endrx) && (!rxto) && (!error));
+
+ m_cb.rx_buffer_length = 0;
+
+ if (error)
+ {
+ return NRF_ERROR_INTERNAL;
+ }
+
+ if (rxto)
+ {
+ return NRF_ERROR_FORBIDDEN;
+ }
+ }
+ else
+ {
+ nrf_uarte_int_enable(NRF_UARTE0, NRF_UARTE_INT_ERROR_MASK | NRF_UARTE_INT_ENDRX_MASK);
+ }
+ return NRF_SUCCESS;
+}
+#endif
+
+ret_code_t nrf_drv_uart_rx(uint8_t * p_data, uint8_t length)
+{
+ ASSERT(m_cb.state == NRF_DRV_STATE_INITIALIZED);
+ ASSERT(length>0);
+
+ CODE_FOR_UARTE
+ (
+ // EasyDMA requires that transfer buffers are placed in DataRAM,
+ // signal error if the are not.
+ if (!IS_EASY_DMA_RAM_ADDRESS(p_data))
+ {
+ return NRF_ERROR_INVALID_ADDR;
+ }
+ )
+
+ bool second_buffer = false;
+
+ if (m_cb.handler)
+ {
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_int_disable(NRF_UARTE0, NRF_UARTE_INT_ERROR_MASK | NRF_UARTE_INT_ENDRX_MASK);
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_int_disable(NRF_UART0, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+ )
+ }
+ if (m_cb.rx_buffer_length != 0)
+ {
+ if (m_cb.rx_secondary_buffer_length != 0)
+ {
+ if (m_cb.handler)
+ {
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_int_enable(NRF_UARTE0, NRF_UARTE_INT_ERROR_MASK | NRF_UARTE_INT_ENDRX_MASK);
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_int_enable(NRF_UART0, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+ )
+ }
+ return NRF_ERROR_BUSY;
+ }
+ second_buffer = true;
+ }
+
+ if (!second_buffer)
+ {
+ m_cb.rx_buffer_length = length;
+ m_cb.p_rx_buffer = p_data;
+ m_cb.rx_counter = 0;
+ m_cb.rx_secondary_buffer_length = 0;
+ }
+ else
+ {
+ m_cb.p_rx_secondary_buffer = p_data;
+ m_cb.rx_secondary_buffer_length = length;
+ }
+
+ CODE_FOR_UARTE
+ (
+ return nrf_drv_uart_rx_for_uarte(p_data, length, second_buffer);
+ )
+ CODE_FOR_UART
+ (
+ return nrf_drv_uart_rx_for_uart(p_data, length, second_buffer);
+ )
+}
+
+void nrf_drv_uart_rx_enable(void)
+{
+ //Easy dma mode does not support enabling receiver without setting up buffer.
+ CODE_FOR_UARTE
+ (
+ ASSERT(false);
+ )
+ CODE_FOR_UART
+ (
+ if (!m_cb.rx_enabled)
+ {
+ rx_enable();
+ m_cb.rx_enabled = true;
+ }
+ )
+}
+
+void nrf_drv_uart_rx_disable(void)
+{
+ //Easy dma mode does not support enabling receiver without setting up buffer.
+ CODE_FOR_UARTE
+ (
+ ASSERT(false);
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STOPRX);
+ m_cb.rx_enabled = false;
+ )
+}
+
+uint32_t nrf_drv_uart_errorsrc_get(void)
+{
+ uint32_t errsrc;
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ERROR);
+ errsrc = nrf_uarte_errorsrc_get_and_clear(NRF_UARTE0);
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_ERROR);
+ errsrc = nrf_uart_errorsrc_get_and_clear(NRF_UART0);
+ )
+ return errsrc;
+}
+
+__STATIC_INLINE void rx_done_event(uint8_t bytes, uint8_t * p_data)
+{
+ nrf_drv_uart_event_t event;
+
+ event.type = NRF_DRV_UART_EVT_RX_DONE;
+ event.data.rxtx.bytes = bytes;
+ event.data.rxtx.p_data = p_data;
+
+ m_cb.handler(&event,m_cb.p_context);
+}
+
+__STATIC_INLINE void tx_done_event(uint8_t bytes)
+{
+ nrf_drv_uart_event_t event;
+
+ event.type = NRF_DRV_UART_EVT_TX_DONE;
+ event.data.rxtx.bytes = bytes;
+ event.data.rxtx.p_data = (uint8_t *)m_cb.p_tx_buffer;
+
+ m_cb.tx_buffer_length = 0;
+
+ m_cb.handler(&event,m_cb.p_context);
+}
+
+void nrf_drv_uart_tx_abort(void)
+{
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_TXSTOPPED);
+ nrf_uarte_task_trigger(NRF_UARTE0, NRF_UARTE_TASK_STOPTX);
+ if (m_cb.handler == NULL)
+ {
+ while(!nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_TXSTOPPED));
+ }
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STOPTX);
+ if (m_cb.handler)
+ {
+ tx_done_event(m_cb.tx_counter);
+ }
+ else
+ {
+ m_cb.tx_counter = TX_COUNTER_ABORT_REQ_VALUE;
+ }
+ )
+}
+
+void nrf_drv_uart_rx_abort(void)
+{
+ CODE_FOR_UARTE
+ (
+ nrf_uarte_task_trigger(NRF_UARTE0, NRF_UARTE_TASK_STOPRX);
+ )
+ CODE_FOR_UART
+ (
+ nrf_uart_int_disable(NRF_UART0, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STOPRX);
+ )
+}
+
+
+#if defined(UART_IN_USE)
+__STATIC_INLINE void uart_irq_handler()
+{
+ if (nrf_uart_int_enable_check(NRF_UART0, NRF_UART_INT_MASK_ERROR) &&
+ nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_ERROR))
+ {
+ nrf_drv_uart_event_t event;
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_ERROR);
+ nrf_uart_int_disable(NRF_UART0, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+ if (!m_cb.rx_enabled)
+ {
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STOPRX);
+ }
+ event.type = NRF_DRV_UART_EVT_ERROR;
+ event.data.error.error_mask = nrf_uart_errorsrc_get_and_clear(NRF_UART0);
+ event.data.error.rxtx.bytes = m_cb.rx_buffer_length;
+ event.data.error.rxtx.p_data = m_cb.p_rx_buffer;
+
+ //abort transfer
+ m_cb.rx_buffer_length = 0;
+ m_cb.rx_secondary_buffer_length = 0;
+
+ m_cb.handler(&event,m_cb.p_context);
+ }
+ else if (nrf_uart_int_enable_check(NRF_UART0, NRF_UART_INT_MASK_RXDRDY) &&
+ nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_RXDRDY))
+ {
+ rx_byte();
+ if (m_cb.rx_buffer_length == m_cb.rx_counter)
+ {
+ if (m_cb.rx_secondary_buffer_length)
+ {
+ uint8_t * p_data = m_cb.p_rx_buffer;
+ uint8_t rx_counter = m_cb.rx_counter;
+
+ //Switch to secondary buffer.
+ m_cb.rx_buffer_length = m_cb.rx_secondary_buffer_length;
+ m_cb.p_rx_buffer = m_cb.p_rx_secondary_buffer;
+ m_cb.rx_secondary_buffer_length = 0;
+ m_cb.rx_counter = 0;
+ rx_done_event(rx_counter, p_data);
+ }
+ else
+ {
+ if (!m_cb.rx_enabled)
+ {
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STOPRX);
+ }
+ nrf_uart_int_disable(NRF_UART0, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+ m_cb.rx_buffer_length = 0;
+ rx_done_event(m_cb.rx_counter, m_cb.p_rx_buffer);
+ }
+ }
+ }
+
+ if (nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_TXDRDY))
+ {
+ if (m_cb.tx_counter < (uint16_t) m_cb.tx_buffer_length)
+ {
+ tx_byte();
+ }
+ else
+ {
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_TXDRDY);
+ if (m_cb.tx_buffer_length)
+ {
+ tx_done_event(m_cb.tx_buffer_length);
+ }
+ }
+ }
+
+ if (nrf_uart_event_check(NRF_UART0, NRF_UART_EVENT_RXTO))
+ {
+ nrf_uart_event_clear(NRF_UART0, NRF_UART_EVENT_RXTO);
+
+ // RXTO event may be triggered as a result of abort call. In th
+ if (m_cb.rx_enabled)
+ {
+ nrf_uart_task_trigger(NRF_UART0, NRF_UART_TASK_STARTRX);
+ }
+ if (m_cb.rx_buffer_length)
+ {
+ m_cb.rx_buffer_length = 0;
+ rx_done_event(m_cb.rx_counter, m_cb.p_rx_buffer);
+ }
+ }
+}
+#endif
+
+#if defined(UARTE_IN_USE)
+__STATIC_INLINE void uarte_irq_handler()
+{
+ if (nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_ERROR))
+ {
+ nrf_drv_uart_event_t event;
+
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ERROR);
+
+ event.type = NRF_DRV_UART_EVT_ERROR;
+ event.data.error.error_mask = nrf_uarte_errorsrc_get_and_clear(NRF_UARTE0);
+ event.data.error.rxtx.bytes = nrf_uarte_rx_amount_get(NRF_UARTE0);
+ event.data.error.rxtx.p_data = m_cb.p_rx_buffer;
+
+ //abort transfer
+ m_cb.rx_buffer_length = 0;
+ m_cb.rx_secondary_buffer_length = 0;
+
+ m_cb.handler(&event,m_cb.p_context);
+ }
+ else if (nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_ENDRX))
+ {
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ENDRX);
+ uint8_t amount = nrf_uarte_rx_amount_get(NRF_UARTE0);
+ // If the transfer was stopped before completion, amount of transfered bytes
+ // will not be equal to the buffer length. Interrupted trunsfer is ignored.
+ if (amount == m_cb.rx_buffer_length)
+ {
+ if (m_cb.rx_secondary_buffer_length)
+ {
+ uint8_t * p_data = m_cb.p_rx_buffer;
+ nrf_uarte_shorts_disable(NRF_UARTE0, NRF_UARTE_SHORT_ENDRX_STARTRX);
+ m_cb.rx_buffer_length = m_cb.rx_secondary_buffer_length;
+ m_cb.p_rx_buffer = m_cb.p_rx_secondary_buffer;
+ m_cb.rx_secondary_buffer_length = 0;
+ rx_done_event(amount, p_data);
+ }
+ else
+ {
+ m_cb.rx_buffer_length = 0;
+ rx_done_event(amount, m_cb.p_rx_buffer);
+ }
+ }
+ }
+
+ if (nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_RXTO))
+ {
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_RXTO);
+ if (m_cb.rx_buffer_length)
+ {
+ m_cb.rx_buffer_length = 0;
+ rx_done_event(nrf_uarte_rx_amount_get(NRF_UARTE0), m_cb.p_rx_buffer);
+ }
+ }
+
+ if (nrf_uarte_event_check(NRF_UARTE0, NRF_UARTE_EVENT_ENDTX))
+ {
+ nrf_uarte_event_clear(NRF_UARTE0, NRF_UARTE_EVENT_ENDTX);
+ if (m_cb.tx_buffer_length)
+ {
+ tx_done_event(nrf_uarte_tx_amount_get(NRF_UARTE0));
+ }
+ }
+}
+#endif
+
+void UART0_IRQHandler(void)
+{
+ CODE_FOR_UARTE
+ (
+ uarte_irq_handler();
+ )
+ CODE_FOR_UART
+ (
+ uart_irq_handler();
+ )
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f06c2d2b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.h
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.h b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.h
new file mode 100644
index 0000000..ed49f14
--- /dev/null
+++ b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/uart/nrf_drv_uart.h
@@ -0,0 +1,293 @@
+/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
+ *
+ * The information contained herein is property of Nordic Semiconductor ASA.
+ * Terms and conditions of usage are described in detail in NORDIC
+ * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
+ *
+ * Licensees are granted free, non-transferable use of the information. NO
+ * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
+ * the file.
+ *
+ */
+
+/**@file
+ * @addtogroup nrf_uart UART driver and HAL
+ * @ingroup nrf_drivers
+ * @brief UART API.
+ * @details The UART driver provides APIs for utilizing the UART peripheral.
+ *
+ * @defgroup nrf_drv_uart UART driver
+ * @{
+ * @ingroup nrf_uart
+ *
+ * @brief UART driver.
+ */
+
+#ifndef NRF_DRV_UART_H
+#define NRF_DRV_UART_H
+
+#include "nrf_uart.h"
+#ifdef NRF52
+#include "nrf_uarte.h"
+#endif
+
+#include "sdk_errors.h"
+#include "nrf_drv_config.h"
+
+/**
+ * @brief Types of UART driver events.
+ */
+typedef enum
+{
+ NRF_DRV_UART_EVT_TX_DONE, ///< Requested TX transfer completed.
+ NRF_DRV_UART_EVT_RX_DONE, ///< Requested RX transfer completed.
+ NRF_DRV_UART_EVT_ERROR, ///< Error reported by UART peripheral.
+} nrf_drv_uart_evt_type_t;
+
+/**@brief Structure for UART configuration. */
+typedef struct
+{
+ uint32_t pseltxd; ///< TXD pin number.
+ uint32_t pselrxd; ///< RXD pin number.
+ uint32_t pselcts; ///< CTS pin number.
+ uint32_t pselrts; ///< RTS pin number.
+ void * p_context; ///< Context passed to interrupt handler.
+ nrf_uart_hwfc_t hwfc; ///< Flow control configuration.
+ nrf_uart_parity_t parity; ///< Parity configuration.
+ nrf_uart_baudrate_t baudrate; ///< Baudrate.
+ uint8_t interrupt_priority; ///< Interrupt priority.
+#ifdef NRF52
+ bool use_easy_dma;
+#endif
+} nrf_drv_uart_config_t;
+
+/**@brief UART default configuration. */
+#ifdef NRF52
+#if !UART_LEGACY_SUPPORT
+#define DEFAULT_CONFIG_USE_EASY_DMA true
+#elif !UART_EASY_DMA_SUPPORT
+#define DEFAULT_CONFIG_USE_EASY_DMA false
+#else
+#define DEFAULT_CONFIG_USE_EASY_DMA UART0_CONFIG_USE_EASY_DMA
+#endif
+#define NRF_DRV_UART_DEFAULT_CONFIG \
+ { \
+ .pseltxd = UART0_CONFIG_PSEL_TXD, \
+ .pselrxd = UART0_CONFIG_PSEL_RXD, \
+ .pselcts = UART0_CONFIG_PSEL_CTS, \
+ .pselrts = UART0_CONFIG_PSEL_RTS, \
+ .p_context = NULL, \
+ .hwfc = UART0_CONFIG_HWFC, \
+ .parity = UART0_CONFIG_PARITY, \
+ .baudrate = UART0_CONFIG_BAUDRATE, \
+ .interrupt_priority = UART0_CONFIG_IRQ_PRIORITY, \
+ .use_easy_dma = DEFAULT_CONFIG_USE_EASY_DMA \
+ }
+#else
+#define NRF_DRV_UART_DEFAULT_CONFIG \
+ { \
+ .pseltxd = UART0_CONFIG_PSEL_TXD, \
+ .pselrxd = UART0_CONFIG_PSEL_RXD, \
+ .pselcts = UART0_CONFIG_PSEL_CTS, \
+ .pselrts = UART0_CONFIG_PSEL_RTS, \
+ .p_context = NULL, \
+ .hwfc = UART0_CONFIG_HWFC, \
+ .parity = UART0_CONFIG_PARITY, \
+ .baudrate = UART0_CONFIG_BAUDRATE, \
+ .interrupt_priority = UART0_CONFIG_IRQ_PRIORITY \
+ }
+#endif
+
+/**@brief Structure for UART transfer completion event. */
+typedef struct
+{
+ uint8_t * p_data; ///< Pointer to memory used for transfer.
+ uint8_t bytes; ///< Number of bytes transfered.
+} nrf_drv_uart_xfer_evt_t;
+
+/**@brief Structure for UART error event. */
+typedef struct
+{
+ nrf_drv_uart_xfer_evt_t rxtx; ///< Transfer details includes number of bytes transfered.
+ uint32_t error_mask;///< Mask of error flags that generated the event.
+} nrf_drv_uart_error_evt_t;
+
+/**@brief Structure for UART event. */
+typedef struct
+{
+ nrf_drv_uart_evt_type_t type; ///< Event type.
+ union
+ {
+ nrf_drv_uart_xfer_evt_t rxtx; ///< Data provided for transfer completion events.
+ nrf_drv_uart_error_evt_t error;///< Data provided for error event.
+ } data;
+} nrf_drv_uart_event_t;
+
+/**
+ * @brief UART interrupt event handler.
+ *
+ * @param[in] p_event Pointer to event structure. Event is allocated on the stack so it is available
+ * only within the context of the event handler.
+ * @param[in] p_context Context passed to interrupt handler, set on initialization.
+ */
+typedef void (*nrf_uart_event_handler_t)(nrf_drv_uart_event_t * p_event, void * p_context);
+
+/**
+ * @brief Function for initializing the UART driver.
+ *
+ * This function configures and enables UART. After this function GPIO pins are controlled by UART.
+ *
+ * @param[in] p_config Initial configuration. Default configuration used if NULL.
+ * @param[in] event_handler Event handler provided by the user. If not provided driver works in
+ * blocking mode.
+ *
+ * @retval NRF_SUCCESS If initialization was successful.
+ * @retval NRF_ERROR_INVALID_STATE If driver is already initialized.
+ */
+ret_code_t nrf_drv_uart_init(nrf_drv_uart_config_t const * p_config,
+ nrf_uart_event_handler_t event_handler);
+
+/**
+ * @brief Function for uninitializing the UART driver.
+ */
+void nrf_drv_uart_uninit(void);
+
+/**
+ * @brief Function for getting the address of a specific UART task.
+ *
+ * @param[in] task Task.
+ *
+ * @return Task address.
+ */
+__STATIC_INLINE uint32_t nrf_drv_uart_task_address_get(nrf_uart_task_t task);
+
+/**
+ * @brief Function for getting the address of a specific UART event.
+ *
+ * @param[in] event Event.
+ *
+ * @return Event address.
+ */
+__STATIC_INLINE uint32_t nrf_drv_uart_event_address_get(nrf_uart_event_t event);
+
+/**
+ * @brief Function for sending data over UART.
+ *
+ * If an event handler was provided in nrf_drv_uart_init() call, this function
+ * returns immediately and the handler is called when the transfer is done.
+ * Otherwise, the transfer is performed in blocking mode, i.e. this function
+ * returns when the transfer is finished. Blocking mode is not using interrupt so
+ * there is no context switching inside the function.
+ *
+ * @note Peripherals using EasyDMA (i.e. UARTE) require that the transfer buffers
+ * are placed in the Data RAM region. If they are not and UARTE instance is
+ * used, this function will fail with error code NRF_ERROR_INVALID_ADDR.
+ *
+ * @param[in] p_data Pointer to data.
+ * @param[in] length Number of bytes to send.
+ *
+ * @retval NRF_SUCCESS If initialization was successful.
+ * @retval NRF_ERROR_BUSY If driver is already transferring.
+ * @retval NRF_ERROR_FORBIDDEN If the transfer was aborted from a different context
+ * (blocking mode only, also see @ref nrf_drv_uart_rx_disable).
+ * @retval NRF_ERROR_INVALID_ADDR If p_data does not point to RAM buffer (UARTE only).
+ */
+ret_code_t nrf_drv_uart_tx(uint8_t const * const p_data, uint8_t length);
+
+/**
+ * @brief Function for checking if UART is currently transmitting.
+ *
+ * @retval true If UART is transmitting.
+ * @retval false If UART is not transmitting.
+ */
+bool nrf_drv_uart_tx_in_progress(void);
+
+/**
+ * @brief Function for aborting any ongoing transmission.
+ * @note @ref NRF_DRV_UART_EVT_TX_DONE event will be generated in non-blocking mode. Event will
+ * contain number of bytes sent until abort was called. If Easy DMA is not used event will be
+ * called from the function context. If Easy DMA is used it will be called from UART interrupt
+ * context.
+ */
+void nrf_drv_uart_tx_abort(void);
+
+/**
+ * @brief Function for receiving data over UART.
+ *
+ * If an event handler was provided in the nrf_drv_uart_init() call, this function
+ * returns immediately and the handler is called when the transfer is done.
+ * Otherwise, the transfer is performed in blocking mode, i.e. this function
+ * returns when the transfer is finished. Blocking mode is not using interrupt so
+ * there is no context switching inside the function.
+ * The receive buffer pointer is double buffered in non-blocking mode. The secondary
+ * buffer can be set immediately after starting the transfer and will be filled
+ * when the primary buffer is full. The double buffering feature allows
+ * receiving data continuously.
+ *
+ * @note Peripherals using EasyDMA (i.e. UARTE) require that the transfer buffers
+ * are placed in the Data RAM region. If they are not and UARTE instance is
+ * used, this function will fail with error code NRF_ERROR_INVALID_ADDR.
+ * @param[in] p_data Pointer to data.
+ * @param[in] length Number of bytes to receive.
+ *
+ * @retval NRF_SUCCESS If initialization was successful.
+ * @retval NRF_ERROR_BUSY If the driver is already receiving
+ * (and the secondary buffer has already been set
+ * in non-blocking mode).
+ * @retval NRF_ERROR_FORBIDDEN If the transfer was aborted from a different context
+ * (blocking mode only, also see @ref nrf_drv_uart_rx_disable).
+ * @retval NRF_ERROR_INTERNAL If UART peripheral reported an error.
+ * @retval NRF_ERROR_INVALID_ADDR If p_data does not point to RAM buffer (UARTE only).
+ */
+ret_code_t nrf_drv_uart_rx(uint8_t * p_data, uint8_t length);
+
+/**
+ * @brief Function for enabling receiver.
+ *
+ * UART has 6 byte long RX FIFO and it will be used to store incoming data. If user will not call
+ * UART receive function before FIFO is filled, overrun error will encounter. Enabling receiver
+ * without specifying RX buffer is supported only in UART mode (without Easy DMA). Receiver must be
+ * explicitly closed by the user @sa nrf_drv_uart_rx_disable. Function asserts if mode is wrong.
+ */
+void nrf_drv_uart_rx_enable(void);
+
+/**
+ * @brief Function for disabling receiver.
+ *
+ * Function must be called to close the receiver after it has been explicitly enabled by
+ * @sa nrf_drv_uart_rx_enable. Feature is supported only in UART mode (without Easy DMA). Function
+ * asserts if mode is wrong.
+ */
+void nrf_drv_uart_rx_disable(void);
+
+/**
+ * @brief Function for aborting any ongoing reception.
+ * @note @ref NRF_DRV_UART_EVT_RX_DONE event will be generated in non-blocking mode. Event will
+ * contain number of bytes received until abort was called. If Easy DMA is not used event will be
+ * called from the function context. If Easy DMA is used it will be called from UART interrupt
+ * context.
+ */
+void nrf_drv_uart_rx_abort(void);
+
+/**
+ * @brief Function for reading error source mask. Mask contains values from @ref nrf_uart_error_mask_t.
+ * @note Function should be used in blocking mode only. In case of non-blocking mode error event is
+ * generated. Function clears error sources after reading.
+ *
+ * @retval Mask of reported errors.
+ */
+uint32_t nrf_drv_uart_errorsrc_get(void);
+
+#ifndef SUPPRESS_INLINE_IMPLEMENTATION
+__STATIC_INLINE uint32_t nrf_drv_uart_task_address_get(nrf_uart_task_t task)
+{
+ return nrf_uart_task_address_get(NRF_UART0, task);
+}
+
+__STATIC_INLINE uint32_t nrf_drv_uart_event_address_get(nrf_uart_event_t event)
+{
+ return nrf_uart_event_address_get(NRF_UART0, event);
+}
+#endif //SUPPRESS_INLINE_IMPLEMENTATION
+#endif //NRF_DRV_UART_H
+/** @} */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f06c2d2b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.c
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.c b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.c
new file mode 100644
index 0000000..bfd684f
--- /dev/null
+++ b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.c
@@ -0,0 +1,118 @@
+/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
+ *
+ * The information contained herein is property of Nordic Semiconductor ASA.
+ * Terms and conditions of usage are described in detail in NORDIC
+ * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
+ *
+ * Licensees are granted free, non-transferable use of the information. NO
+ * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
+ * the file.
+ *
+ */
+
+#include "nrf_drv_wdt.h"
+#include "nrf_drv_common.h"
+#include "nrf_error.h"
+#include "nrf_assert.h"
+#include "nrf_wdt.h"
+#include "app_util_platform.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+/**@brief WDT event handler. */
+static nrf_wdt_event_handler_t m_wdt_event_handler;
+
+/**@brief WDT state. */
+static nrf_drv_state_t m_state;
+
+/**@brief WDT alloc table. */
+static uint32_t m_alloc_index;
+
+static const nrf_drv_wdt_config_t m_default_config = NRF_DRV_WDT_DEAFULT_CONFIG;
+
+/**@brief WDT interrupt handler. */
+void WDT_IRQHandler(void)
+{
+ if (nrf_wdt_int_enable_check(NRF_WDT_INT_TIMEOUT_MASK) == true)
+ {
+ nrf_wdt_event_clear(NRF_WDT_EVENT_TIMEOUT);
+ m_wdt_event_handler();
+ }
+}
+
+
+ret_code_t nrf_drv_wdt_init(nrf_drv_wdt_config_t const * p_config,
+ nrf_wdt_event_handler_t wdt_event_handler)
+{
+ ASSERT(wdt_event_handler != NULL);
+ m_wdt_event_handler = wdt_event_handler;
+
+ if (m_state == NRF_DRV_STATE_UNINITIALIZED)
+ {
+ m_state = NRF_DRV_STATE_INITIALIZED;
+ }
+ else
+ {
+ return NRF_ERROR_INVALID_STATE; // WDT already initialized
+ }
+
+ if (p_config == NULL)
+ {
+ p_config = &m_default_config;
+ }
+
+ nrf_wdt_behaviour_set(p_config->behaviour);
+ nrf_wdt_reload_value_set((p_config->reload_value * 32768) / 1000);
+
+ nrf_drv_common_irq_enable(WDT_IRQn, p_config->interrupt_priority);
+
+ return NRF_SUCCESS;
+}
+
+
+void nrf_drv_wdt_enable(void)
+{
+ ASSERT(m_alloc_index != 0);
+ ASSERT(m_state == NRF_DRV_STATE_INITIALIZED);
+ nrf_wdt_int_enable(NRF_WDT_INT_TIMEOUT_MASK);
+ nrf_wdt_task_trigger(NRF_WDT_TASK_START);
+ m_state = NRF_DRV_STATE_POWERED_ON;
+}
+
+
+void nrf_drv_wdt_feed(void)
+{
+ ASSERT(m_state == NRF_DRV_STATE_POWERED_ON);
+ for(uint32_t i = 0; i < m_alloc_index; i++)
+ {
+ nrf_wdt_reload_request_set((nrf_wdt_rr_register_t)(NRF_WDT_RR0 + i));
+ }
+}
+
+ret_code_t nrf_drv_wdt_channel_alloc(nrf_drv_wdt_channel_id * p_channel_id)
+{
+ ret_code_t result;
+ ASSERT(p_channel_id);
+ ASSERT(m_state == NRF_DRV_STATE_INITIALIZED);
+
+ CRITICAL_REGION_ENTER();
+ if (m_alloc_index < NRF_WDT_CHANNEL_NUMBER)
+ {
+ *p_channel_id = (nrf_drv_wdt_channel_id)(NRF_WDT_RR0 + m_alloc_index);
+ m_alloc_index++;
+ nrf_wdt_reload_request_enable(*p_channel_id);
+ result = NRF_SUCCESS;
+ }
+ else
+ {
+ result = NRF_ERROR_NO_MEM;
+ }
+ CRITICAL_REGION_EXIT();
+ return result;
+}
+
+void nrf_drv_wdt_channel_feed(nrf_drv_wdt_channel_id channel_id)
+{
+ ASSERT(m_state == NRF_DRV_STATE_POWERED_ON);
+ nrf_wdt_reload_request_set(channel_id);
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f06c2d2b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.h
----------------------------------------------------------------------
diff --git a/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.h b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.h
new file mode 100644
index 0000000..338d5bc
--- /dev/null
+++ b/hw/mcu/nordic/src/ext/nRF5_SDK_11.0.0_89a8197/components/drivers_nrf/wdt/nrf_drv_wdt.h
@@ -0,0 +1,124 @@
+/* Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
+ *
+ * The information contained herein is property of Nordic Semiconductor ASA.
+ * Terms and conditions of usage are described in detail in NORDIC
+ * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
+ *
+ * Licensees are granted free, non-transferable use of the information. NO
+ * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
+ * the file.
+ *
+ */
+
+/**@file
+ * @addtogroup nrf_wdt WDT HAL and driver
+ * @ingroup nrf_drivers
+ * @brief Watchdog timer (WDT) APIs.
+ * @details The WDT HAL provides basic APIs for accessing the registers of the watchdog timer.
+ * The WDT driver provides APIs on a higher level.
+ * @defgroup lib_driver_wdt WDT driver
+ * @{
+ * @ingroup nrf_wdt
+ *
+ * @brief Driver for managing the watchdog timer (WDT).
+ */
+
+#ifndef NRF_DRV_WDT_H__
+#define NRF_DRV_WDT_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "sdk_errors.h"
+#include "nrf_wdt.h"
+#include "nrf_drv_config.h"
+
+/**@brief Struct for WDT initialization. */
+typedef struct
+{
+ nrf_wdt_behaviour_t behaviour; /**< WDT behaviour when CPU in sleep/halt mode. */
+ uint32_t reload_value; /**< WDT reload value in ms. */
+ uint8_t interrupt_priority; /**< WDT interrupt priority */
+} nrf_drv_wdt_config_t;
+
+/**@brief WDT event handler function type. */
+typedef void (*nrf_wdt_event_handler_t)(void);
+
+/**@brief WDT channel id type. */
+typedef nrf_wdt_rr_register_t nrf_drv_wdt_channel_id;
+
+#define NRF_DRV_WDT_DEAFULT_CONFIG \
+ { \
+ .behaviour = WDT_CONFIG_BEHAVIOUR, \
+ .reload_value = WDT_CONFIG_RELOAD_VALUE, \
+ .interrupt_priority = WDT_CONFIG_IRQ_PRIORITY, \
+ }
+/**
+ * @brief This function initializes watchdog.
+ *
+ * @param[in] p_config Initial configuration. Default configuration used if NULL.
+ * @param[in] wdt_event_handler specifies event handler provided by user.
+ *
+ * @note Function asserts if wdt_event_handler is NULL.
+ *
+ * @return NRF_SUCCESS on success, NRF_ERROR_INVALID_STATE if module ws already initialized.
+ */
+ret_code_t nrf_drv_wdt_init(nrf_drv_wdt_config_t const * p_config,
+ nrf_wdt_event_handler_t wdt_event_handler);
+
+/**
+ * @brief This function allocate watchdog channel.
+ *
+ * @note This function can not be called after nrf_drv_wdt_start(void).
+ *
+ * @param[out] p_channel_id ID of granted channel.
+ *
+ * @return NRF_SUCCESS on success, otherwise an error code.
+ */
+ret_code_t nrf_drv_wdt_channel_alloc(nrf_drv_wdt_channel_id * p_channel_id);
+
+/**
+ * @brief This function starts watchdog.
+ *
+ * @note After calling this function the watchdog is started, so the user needs to feed all allocated
+ * watchdog channels to avoid reset. At least one watchdog channel has to be allocated.
+ */
+void nrf_drv_wdt_enable(void);
+
+/**
+ * @brief This function feeds the watchdog.
+ *
+ * @details Function feeds all allocated watchdog channels.
+ */
+void nrf_drv_wdt_feed(void);
+
+/**
+ * @brief This function feeds the invidual watchdog channel.
+ *
+ * @param[in] channel_id ID of watchdog channel.
+ */
+void nrf_drv_wdt_channel_feed(nrf_drv_wdt_channel_id channel_id);
+
+/**@brief Function for returning a requested task address for the wdt driver module.
+ *
+ * @param[in] task One of the peripheral tasks.
+ *
+ * @retval Task address.
+ */
+__STATIC_INLINE uint32_t nrf_drv_wdt_ppi_task_addr(nrf_wdt_task_t task)
+{
+ return nrf_wdt_task_address_get(task);
+}
+
+/**@brief Function for returning a requested event address for the wdt driver module.
+ *
+ * @param[in] event One of the peripheral events.
+ *
+ * @retval Event address
+ */
+__STATIC_INLINE uint32_t nrf_drv_wdt_ppi_event_addr(nrf_wdt_event_t event)
+{
+ return nrf_wdt_event_address_get(event);
+}
+#endif
+
+/** @} */