rtc, keeping time

1 files changed, 437 insertions, 0 deletions

diff --git a/drivers_nrf/i2s/nrf_drv_i2s.c b/drivers_nrf/i2s/nrf_drv_i2s.c
new file mode 100644
index 0000000..2d8966f
--- /dev/null
+++ b/drivers_nrf/i2s/nrf_drv_i2s.c
@@ -0,0 +1,437 @@
+/**
+ * Copyright (c) 2015 - 2017, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * 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, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, 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 Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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.
+ * 
+ */
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(I2S)
+#include "nrf_drv_i2s.h"
+#include "nrf_drv_common.h"
+#include "nrf_gpio.h"
+#include "nrf_assert.h"
+#include "app_util_platform.h"
+
+#define NRF_LOG_MODULE_NAME "I2S"
+
+#if I2S_CONFIG_LOG_ENABLED
+#define NRF_LOG_LEVEL       I2S_CONFIG_LOG_LEVEL
+#define NRF_LOG_INFO_COLOR  I2S_CONFIG_INFO_COLOR
+#define NRF_LOG_DEBUG_COLOR I2S_CONFIG_DEBUG_COLOR
+#define EVT_TO_STR(event)   (event == NRF_I2S_EVENT_RXPTRUPD ? "NRF_I2S_EVENT_RXPTRUPD" :                \
+                            (event == NRF_I2S_EVENT_TXPTRUPD ? "NRF_I2S_EVENT_TXPTRUPD" :                \
+                            (event == NRF_I2S_EVENT_STOPPED ? "NRF_I2S_EVENT_STOPPED" : "UNKNOWN EVENT")))
+#else //I2S_CONFIG_LOG_ENABLED
+#define EVT_TO_STR(event)   ""
+#define NRF_LOG_LEVEL       0
+#endif //I2S_CONFIG_LOG_ENABLED
+#include "nrf_log.h"
+#include "nrf_log_ctrl.h"
+
+#define MODULE_INITIALIZED (m_cb.state == NRF_DRV_STATE_INITIALIZED) /**< Macro designating whether the module has been initialized properly. */
+
+// Control block - driver instance local data.
+typedef struct
+{
+    nrf_drv_i2s_data_handler_t handler;
+    nrf_drv_state_t            state;
+
+    bool       synchronized_mode : 1;
+    bool       rx_ready          : 1;
+    bool       tx_ready          : 1;
+    bool       just_started      : 1;
+    uint16_t   buffer_half_size;
+    uint32_t * p_rx_buffer;
+    uint32_t * p_tx_buffer;
+} i2s_control_block_t;
+static i2s_control_block_t m_cb;
+
+
+static nrf_drv_i2s_config_t const m_default_config = NRF_DRV_I2S_DEFAULT_CONFIG;
+
+
+static void configure_pins(nrf_drv_i2s_config_t const * p_config)
+{
+    uint32_t mck_pin, sdout_pin, sdin_pin;
+
+    // Configure pins used by the peripheral:
+
+    // - SCK and LRCK (required) - depending on the mode of operation these
+    //   pins are configured as outputs (in Master mode) or inputs (in Slave
+    //   mode).
+    if (p_config->mode == NRF_I2S_MODE_MASTER)
+    {
+        nrf_gpio_cfg_output(p_config->sck_pin);
+        nrf_gpio_cfg_output(p_config->lrck_pin);
+    }
+    else
+    {
+        nrf_gpio_cfg_input(p_config->sck_pin,  NRF_GPIO_PIN_NOPULL);
+        nrf_gpio_cfg_input(p_config->lrck_pin, NRF_GPIO_PIN_NOPULL);
+    }
+
+    // - MCK (optional) - always output,
+    if (p_config->mck_pin != NRF_DRV_I2S_PIN_NOT_USED)
+    {
+        mck_pin = p_config->mck_pin;
+        nrf_gpio_cfg_output(mck_pin);
+    }
+    else
+    {
+        mck_pin = NRF_I2S_PIN_NOT_CONNECTED;
+    }
+
+    // - SDOUT (optional) - always output,
+    if (p_config->sdout_pin != NRF_DRV_I2S_PIN_NOT_USED)
+    {
+        sdout_pin = p_config->sdout_pin;
+        nrf_gpio_cfg_output(sdout_pin);
+    }
+    else
+    {
+        sdout_pin = NRF_I2S_PIN_NOT_CONNECTED;
+    }
+
+    // - SDIN (optional) - always input.
+    if (p_config->sdin_pin != NRF_DRV_I2S_PIN_NOT_USED)
+    {
+        sdin_pin = p_config->sdin_pin;
+        nrf_gpio_cfg_input(sdin_pin, NRF_GPIO_PIN_NOPULL);
+    }
+    else
+    {
+        sdin_pin = NRF_I2S_PIN_NOT_CONNECTED;
+    }
+
+    nrf_i2s_pins_set(NRF_I2S, p_config->sck_pin, p_config->lrck_pin,
+        mck_pin, sdout_pin, sdin_pin);
+}
+
+
+ret_code_t nrf_drv_i2s_init(nrf_drv_i2s_config_t const * p_config,
+                            nrf_drv_i2s_data_handler_t   handler)
+{
+    ASSERT(handler);
+
+    ret_code_t err_code;
+
+    if (m_cb.state != NRF_DRV_STATE_UNINITIALIZED)
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+
+    if (p_config == NULL)
+    {
+        p_config = &m_default_config;
+    }
+
+    if (!nrf_i2s_configure(NRF_I2S, p_config->mode,
+                                    p_config->format,
+                                    p_config->alignment,
+                                    p_config->sample_width,
+                                    p_config->channels,
+                                    p_config->mck_setup,
+                                    p_config->ratio))
+    {
+        err_code = NRF_ERROR_INVALID_PARAM;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+    configure_pins(p_config);
+
+    m_cb.handler = handler;
+
+    nrf_drv_common_irq_enable(I2S_IRQn, p_config->irq_priority);
+
+    m_cb.state = NRF_DRV_STATE_INITIALIZED;
+
+    err_code = NRF_SUCCESS;
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+
+
+void nrf_drv_i2s_uninit(void)
+{
+    ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
+
+    nrf_drv_i2s_stop();
+
+    nrf_drv_common_irq_disable(I2S_IRQn);
+
+    m_cb.state = NRF_DRV_STATE_UNINITIALIZED;
+    NRF_LOG_INFO("Initialized.\r\n");
+}
+
+
+ret_code_t nrf_drv_i2s_start(uint32_t * p_rx_buffer,
+                             uint32_t * p_tx_buffer,
+                             uint16_t   buffer_size,
+                             uint8_t    flags)
+{
+    ASSERT((p_rx_buffer != NULL) || (p_tx_buffer != NULL));
+
+    uint16_t buffer_half_size = buffer_size / 2;
+    ASSERT(buffer_half_size != 0);
+
+    VERIFY_MODULE_INITIALIZED();
+
+    ret_code_t err_code;
+
+    if ((p_rx_buffer != NULL) && !nrf_drv_is_in_RAM(p_rx_buffer))
+    {
+        err_code = NRF_ERROR_INVALID_ADDR;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+
+    if ((p_tx_buffer != NULL) && !nrf_drv_is_in_RAM(p_tx_buffer))
+    {
+        err_code = NRF_ERROR_INVALID_ADDR;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+
+    // Initially we set up the peripheral to use the first half of each buffer,
+    // then in 'I2S_IRQHandler' we will switch to the second half.
+    nrf_i2s_transfer_set(NRF_I2S, buffer_half_size, p_rx_buffer, p_tx_buffer);
+
+    m_cb.p_rx_buffer      = p_rx_buffer;
+    m_cb.p_tx_buffer      = p_tx_buffer;
+    m_cb.buffer_half_size = buffer_half_size;
+    m_cb.just_started     = true;
+
+    if ((flags & NRF_DRV_I2S_FLAG_SYNCHRONIZED_MODE) &&
+        // [synchronized mode makes sense only when both RX and TX are enabled]
+        (m_cb.p_rx_buffer != NULL) && (m_cb.p_tx_buffer != NULL))
+    {
+        m_cb.synchronized_mode = true;
+        m_cb.rx_ready          = false;
+        m_cb.tx_ready          = false;
+    }
+    else
+    {
+        m_cb.synchronized_mode = false;
+    }
+
+    nrf_i2s_enable(NRF_I2S);
+
+    m_cb.state = NRF_DRV_STATE_POWERED_ON;
+
+    if (m_cb.p_tx_buffer != NULL)
+    {
+        // Get from the application the first portion of data to be sent - we
+        // need to have it in the transmit buffer before we start the transfer.
+        // Unless the synchronized mode is active. In this mode we must wait
+        // with this until the first portion of data is received, so here we
+        // just make sure that there will be silence on the SDOUT line prior
+        // to that moment.
+        if (m_cb.synchronized_mode)
+        {
+            memset(m_cb.p_tx_buffer, 0, buffer_size);
+        }
+        else
+        {
+            m_cb.handler(NULL, m_cb.p_tx_buffer, m_cb.buffer_half_size);
+        }
+    }
+
+    nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD);
+    nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD);
+    nrf_i2s_int_enable(NRF_I2S,
+        NRF_I2S_INT_RXPTRUPD_MASK | NRF_I2S_INT_TXPTRUPD_MASK);
+    nrf_i2s_task_trigger(NRF_I2S, NRF_I2S_TASK_START);
+
+    err_code = NRF_SUCCESS;
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+
+
+void nrf_drv_i2s_stop(void)
+{
+    ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
+
+    // First disable interrupts, then trigger the STOP task, so no spurious
+    // RXPTRUPD and TXPTRUPD events (see FTPAN-55) will be processed.
+    nrf_i2s_int_disable(NRF_I2S,
+        NRF_I2S_INT_RXPTRUPD_MASK | NRF_I2S_INT_TXPTRUPD_MASK);
+
+    nrf_i2s_task_trigger(NRF_I2S, NRF_I2S_TASK_STOP);
+
+    nrf_i2s_disable(NRF_I2S);
+
+    m_cb.state = NRF_DRV_STATE_INITIALIZED;
+
+    NRF_LOG_INFO("Disabled.");
+}
+
+
+void I2S_IRQHandler(void)
+{
+    uint32_t * p_data_received = NULL;
+    uint32_t * p_data_to_send  = NULL;
+
+    if (nrf_i2s_event_check(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD))
+    {
+        nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD);
+        NRF_LOG_DEBUG("Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_I2S_EVENT_TXPTRUPD));
+
+        // If transmission is not enabled, but for some reason the TXPTRUPD
+        // event has been generated, just ignore it.
+        if (m_cb.p_tx_buffer != NULL)
+        {
+            uint32_t * p_tx_buffer_next;
+            if (nrf_i2s_tx_buffer_get(NRF_I2S) == m_cb.p_tx_buffer)
+            {
+                p_tx_buffer_next = m_cb.p_tx_buffer + m_cb.buffer_half_size;
+            }
+            else
+            {
+                p_tx_buffer_next = m_cb.p_tx_buffer;
+            }
+            nrf_i2s_tx_buffer_set(NRF_I2S, p_tx_buffer_next);
+
+            m_cb.tx_ready = true;
+
+            // Now the part of the buffer that we've configured as "next" should
+            // be filled by the application with proper data to be sent;
+            // the peripheral is sending data from the other part of the buffer
+            // (but it will finish soon...).
+            p_data_to_send = p_tx_buffer_next;
+
+        }
+    }
+
+    if (nrf_i2s_event_check(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD))
+    {
+        nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD);
+        NRF_LOG_DEBUG("Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_I2S_EVENT_RXPTRUPD));
+
+        // If reception is not enabled, but for some reason the RXPTRUPD event
+        // has been generated, just ignore it.
+        if (m_cb.p_rx_buffer != NULL)
+        {
+            uint32_t * p_rx_buffer_next;
+            if (nrf_i2s_rx_buffer_get(NRF_I2S) == m_cb.p_rx_buffer)
+            {
+                p_rx_buffer_next = m_cb.p_rx_buffer + m_cb.buffer_half_size;
+            }
+            else
+            {
+                p_rx_buffer_next = m_cb.p_rx_buffer;
+            }
+            nrf_i2s_rx_buffer_set(NRF_I2S, p_rx_buffer_next);
+
+            m_cb.rx_ready = true;
+
+            // The RXPTRUPD event is generated for the first time right after
+            // the transfer is started. Since there is no data received yet at
+            // this point we only update the buffer pointer (it is done above),
+            // there is no callback to the application.
+            // [for synchronized mode this has to be handled differently -
+            //  see below]
+            if (m_cb.just_started && !m_cb.synchronized_mode)
+            {
+                m_cb.just_started = false;
+            }
+            else
+            {
+                // The RXPTRUPD event indicates that from now on the peripheral
+                // will be filling the part of the buffer that was pointed at
+                // the time the event has been generated, hence now we can let
+                // the application process the data stored in the other part of
+                // the buffer - the one that we've just set to be filled next.
+                p_data_received = p_rx_buffer_next;
+            }
+        }
+    }
+
+    // Call the data handler passing received data to the application and/or
+    // requesting data to be sent.
+    if (!m_cb.synchronized_mode)
+    {
+        if ((p_data_received != NULL) || (p_data_to_send != NULL))
+        {
+            if (p_data_received != NULL)
+            {
+                NRF_LOG_DEBUG("Rx data:\r\n");
+                NRF_LOG_HEXDUMP_DEBUG((uint8_t *)p_data_received,
+                                        m_cb.buffer_half_size * sizeof(p_data_received));
+            }
+            m_cb.handler(p_data_received, p_data_to_send,
+                m_cb.buffer_half_size);
+            if (p_data_to_send != NULL)
+            {
+                NRF_LOG_DEBUG("Tx data:\r\n");
+                NRF_LOG_HEXDUMP_DEBUG((uint8_t *)p_data_to_send,
+                                        m_cb.buffer_half_size * sizeof(p_data_to_send));
+            }
+        }
+    }
+    // In the synchronized mode wait until the events for both RX and TX occur.
+    // And ignore the initial occurrences of these events, since they only
+    // indicate that the transfer has started - no data is received yet at
+    // that moment, so we have got nothing to pass to the application.
+    else
+    {
+        if (m_cb.rx_ready && m_cb.tx_ready)
+        {
+            m_cb.rx_ready = false;
+            m_cb.tx_ready = false;
+
+            if (m_cb.just_started)
+            {
+                m_cb.just_started = false;
+            }
+            else
+            {
+                NRF_LOG_DEBUG("Rx data:\r\n");
+                NRF_LOG_HEXDUMP_DEBUG((uint8_t *)nrf_i2s_rx_buffer_get(NRF_I2S),
+                                        m_cb.buffer_half_size * sizeof(p_data_to_send));
+                m_cb.handler(nrf_i2s_rx_buffer_get(NRF_I2S),
+                             nrf_i2s_tx_buffer_get(NRF_I2S),
+                             m_cb.buffer_half_size);
+                NRF_LOG_DEBUG("Tx data:\r\n");
+                NRF_LOG_HEXDUMP_DEBUG((uint8_t *)nrf_i2s_tx_buffer_get(NRF_I2S),
+                                        m_cb.buffer_half_size * sizeof(p_data_to_send));
+            }
+        }
+    }
+}
+#endif //NRF_MODULE_ENABLED(I2S)