copy project from century 2in6 esl project

COMPONENTS/serialization/common/transport/dtm_uart_params.h

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2013 - 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.
+ * 
+ */
+
+#ifndef DTM_UART_PARAMS_H__
+#define DTM_UART_PARAMS_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @ingroup ble_dtm_app
+ */
+
+
+/**@brief Enumeration of supported baud rates. */
+typedef enum
+{
+    UART_BAUD_RATE_1200,     /**< Baud rate 1200. */
+    UART_BAUD_RATE_2400,     /**< Baud rate 2400. */
+    UART_BAUD_RATE_4800,     /**< Baud rate 4800. */
+    UART_BAUD_RATE_9600,     /**< Baud rate 9600. */
+    UART_BAUD_RATE_14400,    /**< Baud rate 14400. */
+    UART_BAUD_RATE_19200,    /**< Baud rate 19200. */
+    UART_BAUD_RATE_28800,    /**< Baud rate 28800. */
+    UART_BAUD_RATE_38400,    /**< Baud rate 38400. */
+    UART_BAUD_RATE_57600,    /**< Baud rate 57600. */
+    UART_BAUD_RATE_76800,    /**< Baud rate 76800. */
+    UART_BAUD_RATE_115200,   /**< Baud rate 115200. */
+    UART_BAUD_RATE_230400,   /**< Baud rate 230400. */
+    UART_BAUD_RATE_250000,   /**< Baud rate 250000. */
+    UART_BAUD_RATE_460800,   /**< Baud rate 460800. */
+    UART_BAUD_RATE_921600,   /**< Baud rate 921600. */
+    UART_BAUD_RATE_1000000,  /**< Baud rate 1000000. */
+    UART_BAUD_RATE_MAX       /**< Enumeration upper bound. */
+} app_uart_stream_baud_rate_t;
+
+/**@brief UART communication structure holding configuration settings for the peripheral.
+ */
+typedef struct
+{
+    uint8_t                     rx_pin_no;      /**< RX pin number. */
+    uint8_t                     tx_pin_no;      /**< TX pin number. */
+    uint8_t                     rts_pin_no;     /**< RTS pin number, only used if flow control is enabled. */
+    uint8_t                     cts_pin_no;     /**< CTS pin number, only used if flow control is enabled. */
+    bool                        use_parity;     /**< Even parity if TRUE, no parity if FALSE. */
+    app_uart_stream_baud_rate_t baud_rate;      /**< Baud rate configuration. */
+} app_uart_stream_comm_params_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // DTM_UART_PARAMS_H__

COMPONENTS/serialization/common/transport/ser_hal_transport.c

@@ -0,0 +1,488 @@
+/**
+ * Copyright (c) 2014 - 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 <stdbool.h>
+#include <string.h>
+#include "app_error.h"
+#include "ser_config.h"
+#include "ser_phy.h"
+#include "ser_hal_transport.h"
+
+/**
+ * @brief States of the RX state machine.
+ */
+typedef enum
+{
+    HAL_TRANSP_RX_STATE_CLOSED = 0,
+    HAL_TRANSP_RX_STATE_IDLE,
+    HAL_TRANSP_RX_STATE_RECEIVING,
+    HAL_TRANSP_RX_STATE_DROPPING,
+    HAL_TRANSP_RX_STATE_RECEIVED,
+    HAL_TRANSP_RX_STATE_RECEIVED_PENDING_BUF_REQ,
+    HAL_TRANSP_RX_STATE_RECEIVED_DROPPING,
+    HAL_TRANSP_RX_STATE_MAX
+}ser_hal_transp_rx_states_t;
+
+/**
+ * @brief States of the TX state machine.
+ */
+typedef enum
+{
+    HAL_TRANSP_TX_STATE_CLOSED = 0,
+    HAL_TRANSP_TX_STATE_IDLE,
+    HAL_TRANSP_TX_STATE_TX_ALLOCATED,
+    HAL_TRANSP_TX_STATE_TRANSMITTING,
+    HAL_TRANSP_TX_STATE_TRANSMITTED,
+    HAL_TRANSP_TX_STATE_MAX
+}ser_hal_transp_tx_states_t;
+
+/**
+ * @brief RX state.
+ */
+static ser_hal_transp_rx_states_t m_rx_state = HAL_TRANSP_RX_STATE_CLOSED;
+/**
+ * @brief TX state.
+ */
+static ser_hal_transp_tx_states_t m_tx_state = HAL_TRANSP_TX_STATE_CLOSED;
+
+/**
+ * @brief Transmission buffer.
+ */
+static uint8_t m_tx_buffer[SER_HAL_TRANSPORT_TX_MAX_PKT_SIZE];
+/**
+ * @brief Reception buffer.
+ */
+static uint8_t m_rx_buffer[SER_HAL_TRANSPORT_RX_MAX_PKT_SIZE];
+
+/**
+ * @brief Callback function handler for Serialization HAL Transport layer events.
+ */
+static ser_hal_transport_events_handler_t m_events_handler = NULL;
+
+
+/**
+ * @brief A callback function to be used to handle a PHY module events. This function is called in
+ *        an interrupt context.
+ */
+static void phy_events_handler(ser_phy_evt_t phy_event)
+{
+    uint32_t                err_code = 0;
+    ser_hal_transport_evt_t hal_transp_event;
+
+    memset(&hal_transp_event, 0, sizeof (ser_hal_transport_evt_t));
+    hal_transp_event.evt_type = SER_HAL_TRANSP_EVT_TYPE_MAX;
+
+    switch (phy_event.evt_type)
+    {
+        case SER_PHY_EVT_TX_PKT_SENT:
+        {
+            if (HAL_TRANSP_TX_STATE_TRANSMITTING == m_tx_state)
+            {
+                m_tx_state = HAL_TRANSP_TX_STATE_TRANSMITTED;
+                err_code   = ser_hal_transport_tx_pkt_free(m_tx_buffer);
+                APP_ERROR_CHECK(err_code);
+                /* An event to an upper layer that a packet has been transmitted. */
+                hal_transp_event.evt_type = SER_HAL_TRANSP_EVT_TX_PKT_SENT;
+                m_events_handler(hal_transp_event);
+            }
+            else
+            {
+                /* Lower layer should not generate this event in current state. */
+                APP_ERROR_CHECK_BOOL(false);
+            }
+            break;
+        }
+
+        case SER_PHY_EVT_RX_BUF_REQUEST:
+        {
+            /* An event to an upper layer that a packet is being scheduled to receive or to drop. */
+            hal_transp_event.evt_type = SER_HAL_TRANSP_EVT_RX_PKT_RECEIVING;
+
+            /* Receive or drop a packet. */
+            if (phy_event.evt_params.rx_buf_request.num_of_bytes <= sizeof (m_rx_buffer))
+            {
+                if (HAL_TRANSP_RX_STATE_IDLE == m_rx_state)
+                {
+                    m_events_handler(hal_transp_event);
+                    err_code = ser_phy_rx_buf_set(m_rx_buffer);
+                    APP_ERROR_CHECK(err_code);
+                    m_rx_state = HAL_TRANSP_RX_STATE_RECEIVING;
+                }
+                else if (HAL_TRANSP_RX_STATE_RECEIVED == m_rx_state)
+                {
+                    /* It is OK to get know higher layer at this point that we are going to receive
+                     * a new packet even though we will start receiving when rx buffer is freed. */
+                    m_events_handler(hal_transp_event);
+                    m_rx_state = HAL_TRANSP_RX_STATE_RECEIVED_PENDING_BUF_REQ;
+                }
+                else
+                {
+                    /* Lower layer should not generate this event in current state. */
+                    APP_ERROR_CHECK_BOOL(false);
+                }
+            }
+            else
+            {
+                /* There is not enough memory but packet has to be received to dummy location. */
+                if (HAL_TRANSP_RX_STATE_IDLE == m_rx_state)
+                {
+                    m_events_handler(hal_transp_event);
+                    err_code = ser_phy_rx_buf_set(NULL);
+                    APP_ERROR_CHECK(err_code);
+                    m_rx_state = HAL_TRANSP_RX_STATE_DROPPING;
+                }
+                else if (HAL_TRANSP_RX_STATE_RECEIVED == m_rx_state)
+                {
+                    m_events_handler(hal_transp_event);
+                    err_code = ser_phy_rx_buf_set(NULL);
+                    APP_ERROR_CHECK(err_code);
+                    m_rx_state = HAL_TRANSP_RX_STATE_RECEIVED_DROPPING;
+                }
+                else
+                {
+                    /* Lower layer should not generate this event in current state. */
+                    APP_ERROR_CHECK_BOOL(false);
+                }
+            }
+            break;
+        }
+
+        case SER_PHY_EVT_RX_PKT_RECEIVED:
+        {
+            if (HAL_TRANSP_RX_STATE_RECEIVING == m_rx_state)
+            {
+                m_rx_state = HAL_TRANSP_RX_STATE_RECEIVED;
+                /* Generate the event to an upper layer. */
+                hal_transp_event.evt_type =
+                    SER_HAL_TRANSP_EVT_RX_PKT_RECEIVED;
+                hal_transp_event.evt_params.rx_pkt_received.p_buffer =
+                    phy_event.evt_params.rx_pkt_received.p_buffer;
+                hal_transp_event.evt_params.rx_pkt_received.num_of_bytes =
+                    phy_event.evt_params.rx_pkt_received.num_of_bytes;
+                m_events_handler(hal_transp_event);
+            }
+            else
+            {
+                /* Lower layer should not generate this event in current state. */
+                APP_ERROR_CHECK_BOOL(false);
+            }
+            break;
+        }
+
+        case SER_PHY_EVT_RX_PKT_DROPPED:
+        {
+            if (HAL_TRANSP_RX_STATE_DROPPING == m_rx_state)
+            {
+                /* Generate the event to an upper layer. */
+                hal_transp_event.evt_type = SER_HAL_TRANSP_EVT_RX_PKT_DROPPED;
+                m_events_handler(hal_transp_event);
+                m_rx_state = HAL_TRANSP_RX_STATE_IDLE;
+            }
+            else if (HAL_TRANSP_RX_STATE_RECEIVED_DROPPING == m_rx_state)
+            {
+                /* Generate the event to an upper layer. */
+                hal_transp_event.evt_type = SER_HAL_TRANSP_EVT_RX_PKT_DROPPED;
+                m_events_handler(hal_transp_event);
+                m_rx_state = HAL_TRANSP_RX_STATE_RECEIVED;
+            }
+            else
+            {
+                /* Lower layer should not generate this event in current state. */
+                APP_ERROR_CHECK_BOOL(false);
+            }
+            break;
+        }
+
+        case SER_PHY_EVT_RX_OVERFLOW_ERROR:
+        {
+            /* Generate the event to an upper layer. */
+            hal_transp_event.evt_type                        = SER_HAL_TRANSP_EVT_PHY_ERROR;
+            hal_transp_event.evt_params.phy_error.error_type =
+                SER_HAL_TRANSP_PHY_ERROR_RX_OVERFLOW;
+            m_events_handler(hal_transp_event);
+            break;
+        }
+
+        case SER_PHY_EVT_TX_OVERREAD_ERROR:
+        {
+            /* Generate the event to an upper layer. */
+            hal_transp_event.evt_type                        = SER_HAL_TRANSP_EVT_PHY_ERROR;
+            hal_transp_event.evt_params.phy_error.error_type =
+                SER_HAL_TRANSP_PHY_ERROR_TX_OVERREAD;
+            m_events_handler(hal_transp_event);
+            break;
+        }
+
+        case SER_PHY_EVT_HW_ERROR:
+        {
+            /* Generate the event to an upper layer. */
+            hal_transp_event.evt_type                        = SER_HAL_TRANSP_EVT_PHY_ERROR;
+            hal_transp_event.evt_params.phy_error.error_type =
+                SER_HAL_TRANSP_PHY_ERROR_HW_ERROR;
+            hal_transp_event.evt_params.phy_error.hw_error_code =
+                phy_event.evt_params.hw_error.error_code;
+            if (HAL_TRANSP_TX_STATE_TRANSMITTING == m_tx_state)
+            {
+                m_tx_state = HAL_TRANSP_TX_STATE_TRANSMITTED;
+                err_code   = ser_hal_transport_tx_pkt_free(phy_event.evt_params.hw_error.p_buffer);
+                APP_ERROR_CHECK(err_code);
+                /* An event to an upper layer that a packet has been transmitted. */
+            }
+            else if (HAL_TRANSP_RX_STATE_RECEIVING == m_rx_state)
+            {
+                m_rx_state = HAL_TRANSP_RX_STATE_RECEIVED;
+                err_code   = ser_hal_transport_rx_pkt_free(phy_event.evt_params.hw_error.p_buffer);
+                APP_ERROR_CHECK(err_code);
+            }
+            m_events_handler(hal_transp_event);
+
+            break;
+        }
+
+        default:
+        {
+            APP_ERROR_CHECK_BOOL(false);
+            break;
+        }
+    }
+}
+
+uint32_t ser_hal_transport_open(ser_hal_transport_events_handler_t events_handler)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    if ((HAL_TRANSP_RX_STATE_CLOSED != m_rx_state) || (HAL_TRANSP_TX_STATE_CLOSED != m_tx_state))
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+    }
+    else if (NULL == events_handler)
+    {
+        err_code = NRF_ERROR_NULL;
+    }
+    else
+    {
+        /* We have to change states before calling lower layer because ser_phy_open() function is
+         * going to enable interrupts. On success an event from PHY layer can be emitted immediately
+         * after return from ser_phy_open(). */
+        m_rx_state = HAL_TRANSP_RX_STATE_IDLE;
+        m_tx_state = HAL_TRANSP_TX_STATE_IDLE;
+
+        m_events_handler = events_handler;
+
+        /* Initialize a PHY module. */
+        err_code = ser_phy_open(phy_events_handler);
+
+        if (NRF_SUCCESS != err_code)
+        {
+            m_rx_state       = HAL_TRANSP_RX_STATE_CLOSED;
+            m_tx_state       = HAL_TRANSP_TX_STATE_CLOSED;
+            m_events_handler = NULL;
+
+            if (NRF_ERROR_INVALID_PARAM != err_code)
+            {
+                err_code = NRF_ERROR_INTERNAL;
+            }
+        }
+    }
+
+    return err_code;
+}
+
+
+void ser_hal_transport_close(void)
+{
+    /* Reset generic handler for all events, reset internal states and close PHY module. */
+    ser_phy_interrupts_disable();
+    m_rx_state = HAL_TRANSP_RX_STATE_CLOSED;
+    m_tx_state = HAL_TRANSP_TX_STATE_CLOSED;
+
+    m_events_handler = NULL;
+
+    ser_phy_close();
+}
+
+
+uint32_t ser_hal_transport_rx_pkt_free(uint8_t * p_buffer)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    ser_phy_interrupts_disable();
+
+    if (NULL == p_buffer)
+    {
+        err_code = NRF_ERROR_NULL;
+    }
+    else if (p_buffer != m_rx_buffer)
+    {
+        err_code = NRF_ERROR_INVALID_ADDR;
+    }
+    else if (HAL_TRANSP_RX_STATE_RECEIVED == m_rx_state)
+    {
+        m_rx_state = HAL_TRANSP_RX_STATE_IDLE;
+    }
+    else if (HAL_TRANSP_RX_STATE_RECEIVED_DROPPING == m_rx_state)
+    {
+        m_rx_state = HAL_TRANSP_RX_STATE_DROPPING;
+    }
+    else if (HAL_TRANSP_RX_STATE_RECEIVED_PENDING_BUF_REQ == m_rx_state)
+    {
+        err_code = ser_phy_rx_buf_set(m_rx_buffer);
+
+        if (NRF_SUCCESS == err_code)
+        {
+            m_rx_state = HAL_TRANSP_RX_STATE_RECEIVING;
+        }
+        else
+        {
+            err_code = NRF_ERROR_INTERNAL;
+        }
+    }
+    else
+    {
+        /* Upper layer should not call this function in current state. */
+        err_code = NRF_ERROR_INVALID_STATE;
+    }
+    ser_phy_interrupts_enable();
+
+    return err_code;
+}
+
+
+uint32_t ser_hal_transport_tx_pkt_alloc(uint8_t * * pp_memory, uint16_t * p_num_of_bytes)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    if ((NULL == pp_memory) || (NULL == p_num_of_bytes))
+    {
+        err_code = NRF_ERROR_NULL;
+    }
+    else if (HAL_TRANSP_TX_STATE_CLOSED == m_tx_state)
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+    }
+    else if (HAL_TRANSP_TX_STATE_IDLE == m_tx_state)
+    {
+        m_tx_state      = HAL_TRANSP_TX_STATE_TX_ALLOCATED;
+        *pp_memory      = &m_tx_buffer[0];
+        *p_num_of_bytes = (uint16_t)sizeof (m_tx_buffer);
+    }
+    else
+    {
+        err_code = NRF_ERROR_NO_MEM;
+    }
+
+    return err_code;
+}
+
+
+uint32_t ser_hal_transport_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    /* The buffer provided to this function must be allocated through ser_hal_transport_tx_alloc()
+     * function - this assures correct state and that correct memory buffer is used. */
+    if (NULL == p_buffer)
+    {
+        err_code = NRF_ERROR_NULL;
+    }
+    else if (0 == num_of_bytes)
+    {
+        err_code = NRF_ERROR_INVALID_PARAM;
+    }
+    else if (p_buffer != m_tx_buffer)
+    {
+        err_code = NRF_ERROR_INVALID_ADDR;
+    }
+    else if (num_of_bytes > sizeof (m_tx_buffer))
+    {
+        err_code = NRF_ERROR_DATA_SIZE;
+    }
+    else if (HAL_TRANSP_TX_STATE_TX_ALLOCATED == m_tx_state)
+    {
+        ser_phy_interrupts_disable();
+        err_code = ser_phy_tx_pkt_send(p_buffer, num_of_bytes);
+
+        if (NRF_SUCCESS == err_code)
+        {
+            m_tx_state = HAL_TRANSP_TX_STATE_TRANSMITTING;
+        }
+        else
+        {
+            if (NRF_ERROR_BUSY != err_code)
+            {
+                err_code = NRF_ERROR_INTERNAL;
+            }
+        }
+        ser_phy_interrupts_enable();
+    }
+    else
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+    }
+
+    return err_code;
+}
+
+
+uint32_t ser_hal_transport_tx_pkt_free(uint8_t * p_buffer)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    if (NULL == p_buffer)
+    {
+        err_code = NRF_ERROR_NULL;
+    }
+    else if (p_buffer != m_tx_buffer)
+    {
+        err_code = NRF_ERROR_INVALID_ADDR;
+    }
+    else if ((HAL_TRANSP_TX_STATE_TX_ALLOCATED == m_tx_state) ||
+             (HAL_TRANSP_TX_STATE_TRANSMITTED == m_tx_state))
+    {
+        /* Release TX buffer for use. */
+        m_tx_state = HAL_TRANSP_TX_STATE_IDLE;
+    }
+    else
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+    }
+
+    return err_code;
+}

COMPONENTS/serialization/common/transport/ser_hal_transport.h

@@ -0,0 +1,267 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/** @file
+ *
+ * @defgroup ser_hal_transport Serialization HAL Transport
+ * @{
+ * @ingroup ble_sdk_lib_serialization
+ *
+ * @brief   @tagAPI52832 HAL Transport layer for serialization.
+ *
+ * @details This section contains declarations of functions and typedefs used as API of the HAL
+ *          Transport layer for serialization. This layer is fully hardware independent.
+ *          Currently, the HAL Transport layer is responsible for controlling the PHY layer and
+ *          memory management. In the future, it is possible to add more features to it, such as crc 
+ *          or retransmission.
+ *
+ * \n \n
+ * \image html ser_hal_transport_rx_state_machine.svg "RX state machine"
+ * \n \n
+ * \image html ser_hal_transport_tx_state_machine.svg "TX state machine"
+ * \n
+ */
+
+#ifndef SER_HAL_TRANSPORT_H__
+#define SER_HAL_TRANSPORT_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**@brief Serialization HAL Transport layer event types. */
+typedef enum
+{
+    SER_HAL_TRANSP_EVT_TX_PKT_SENT = 0,     /**< An event indicating that TX packet has been
+                                                 transmitted. */
+    SER_HAL_TRANSP_EVT_RX_PKT_RECEIVING,    /**< An event indicating that RX packet is being
+                                                 scheduled to receive or to drop. */
+    SER_HAL_TRANSP_EVT_RX_PKT_RECEIVED,     /**< An event indicating that RX packet is ready for
+                                                 read. */
+    SER_HAL_TRANSP_EVT_RX_PKT_DROPPED,      /**< An event indicating that RX packet was dropped
+                                                 because it was longer than available buffer. */
+    SER_HAL_TRANSP_EVT_PHY_ERROR,           /**< An event indicating error on PHY layer. */
+    SER_HAL_TRANSP_EVT_TYPE_MAX             /**< Enumeration upper bound. */
+} ser_hal_transport_evt_type_t;
+
+
+/**@brief Serialization PHY layer error types. */
+typedef enum
+{
+    SER_HAL_TRANSP_PHY_ERROR_RX_OVERFLOW = 0, /**< An error indicating that more information has
+                                                   been transmitted than the PHY module could handle. */
+    SER_HAL_TRANSP_PHY_ERROR_TX_OVERREAD,     /**< An error indicating that the PHY module was forced to
+                                                   transmit more information than possessed. */
+    SER_HAL_TRANSP_PHY_ERROR_HW_ERROR,        /**< An error indicating a hardware error in the PHY
+                                                   module. */
+    SER_HAL_TRANSP_PHY_ERROR_TYPE_MAX         /**< Enumeration upper bound. */
+} ser_hal_transport_phy_error_type_t;
+
+
+/**@brief Struct containing parameters of event of type
+ *        @ref SER_HAL_TRANSP_EVT_RX_PKT_RECEIVED.
+ */
+typedef struct
+{
+    uint8_t * p_buffer;     /**< Pointer to a buffer containing a packet to read. */
+    uint16_t  num_of_bytes; /**< Length of a received packet in octets. */
+} ser_hal_transport_evt_rx_pkt_received_params_t;
+
+
+/**@brief Struct containing parameters of event of type @ref SER_HAL_TRANSP_EVT_PHY_ERROR. */
+typedef struct
+{
+    ser_hal_transport_phy_error_type_t error_type; /**< Type of the PHY error. */
+    uint32_t hw_error_code; /**< Hardware error code - specific for a microcontroller. Parameter
+                                 is valid only for the PHY error of type
+                                 @ref SER_HAL_TRANSP_PHY_ERROR_HW_ERROR. */
+} ser_hal_transport_evt_phy_error_params_t;
+
+
+/**@brief Struct containing events from the Serialization HAL Transport layer.
+ *
+ * @note  Some events do not have parameters, then the whole information is contained in the evt_type.
+ */
+typedef struct
+{
+    ser_hal_transport_evt_type_t evt_type;  /**< Type of event. */
+    union  /**< Union alternative identified by evt_type in the enclosing struct. */
+    {
+        ser_hal_transport_evt_rx_pkt_received_params_t  rx_pkt_received; /**< Parameters of event of type @ref SER_HAL_TRANSP_EVT_RX_PKT_RECEIVED. */
+        ser_hal_transport_evt_phy_error_params_t        phy_error;       /**< Parameters of event of type @ref SER_HAL_TRANSP_EVT_PHY_ERROR. */
+    } evt_params;
+} ser_hal_transport_evt_t;
+
+
+/**@brief Generic callback function type to be used by all Serialization HAL Transport layer
+ *        events.
+ *
+ * @param[in] event    Serialization HAL Transport layer event.
+ */
+typedef void (*ser_hal_transport_events_handler_t)(ser_hal_transport_evt_t event);
+
+
+/**@brief Function for opening and initializing the Serialization HAL Transport layer.
+ *
+ * @note The function opens the transport channel, initializes a PHY layer, and registers the callback
+ *       function to be used by all Serialization HAL Transport layer events.
+ *
+ * @warning If the function has been already called, the function @ref ser_hal_transport_close has
+ *          to be called before ser_hal_transport_open can be called again.
+ *
+ * @param[in] events_handler    Generic callback function to be used by all Serialization HAL
+ *                              Transport layer events.
+ *
+ * @retval NRF_SUCCESS              Operation success.
+ * @retval NRF_ERROR_NULL           Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_PARAM  Operation failure. Hardware initialization parameters taken from
+ *                                  the configuration file are wrong.
+ * @retval NRF_ERROR_INVALID_STATE  Operation failure. The function has been already called. To call
+ *                                  it again the function @ref ser_hal_transport_close has to be
+ *                                  called first.
+ * @retval NRF_ERROR_INTERNAL       Operation failure. Internal error ocurred.
+ */
+uint32_t ser_hal_transport_open(ser_hal_transport_events_handler_t events_handler);
+
+
+/**@brief Function for closing a transport channel.
+ *
+ * @note The function disables the hardware, resets internal module states, and unregisters the events
+ *       callback function. Can be called multiple times, also for a channel that is not opened.
+ */
+void ser_hal_transport_close(void);
+
+
+/**@brief Function for freeing memory allocated for an RX packet.
+ *
+ * @note The function should be called as a response to an event of type
+ *       @ref SER_HAL_TRANSP_EVT_RX_PKT_RECEIVED when the received data has beed processed. The function
+ *       frees the RX memory pointed by p_buffer. The memory, immediately or at a later time, is
+ *       reused by the underlying transport layer.
+ *
+ * @param[in] p_buffer    A pointer to the beginning of the buffer that has been processed (has to be
+ *                        the same address as provided in the event of type
+ *                        @ref SER_HAL_TRANSP_EVT_RX_PKT_RECEIVED).
+ *
+ * @retval NRF_SUCCESS              Operation success.
+ * @retval NRF_ERROR_NULL           Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_ADDR   Operation failure. Not a valid pointer (provided address is not
+ *                                  the starting address of a buffer managed by HAL Transport layer).
+ * @retval NRF_ERROR_INVALID_STATE  Operation failure. The function should be called as a response
+ *                                  to an event of type @ref SER_HAL_TRANSP_EVT_RX_PKT_RECEIVED.
+ * @retval NRF_ERROR_INTERNAL       Operation failure. Internal error ocurred.
+ */
+uint32_t ser_hal_transport_rx_pkt_free(uint8_t * p_buffer);
+
+
+/**@brief Function for allocating memory for a TX packet.
+ *
+ * @param[out] pp_memory       A pointer to pointer to which an address of the beginning of the
+ *                             allocated buffer is written.
+ * @param[out] p_num_of_bytes  A pointer to a variable to which size in octets of the allocated
+ *                             buffer is written.
+ *
+ * @retval NRF_SUCCESS              Operation success. Memory was allocated.
+ * @retval NRF_ERROR_NULL           Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_NO_MEM         Operation failure. No memory available.
+ * @retval NRF_ERROR_INVALID_STATE  Operation failure. The function was called before calling
+ *                                  @ref ser_hal_transport_open function.
+ */
+uint32_t ser_hal_transport_tx_pkt_alloc(uint8_t ** pp_memory, uint16_t * p_num_of_bytes);
+
+/**@brief Function for transmitting a packet.
+ *
+ * @note The function adds a packet pointed by the p_buffer parameter to a transmission queue. A buffer
+ *       provided to this function must be allocated by the @ref ser_hal_transport_tx_pkt_alloc function.
+ *
+ * @warning Completion of this method does not guarantee that actual peripheral transmission will be completed.
+ *
+ * @param[in] p_buffer        Pointer to the buffer to transmit.
+ * @param[in] num_of_bytes    Number of octets to transmit. Must be more than 0.
+ *
+ * @retval NRF_SUCCESS              Operation success. Packet was added to the transmission queue.
+ * @retval NRF_ERROR_NULL           Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_PARAM  Operation failure. num_of_bytes is equal to 0.
+ * @retval NRF_ERROR_INVALID_ADDR   Operation failure. Not a valid pointer (provided address is not
+ *                                  the starting address of a buffer managed by HAL Transport layer).
+ * @retval NRF_ERROR_DATA_SIZE      Operation failure. Packet size exceeds limit.
+ * @retval NRF_ERROR_BUSY           Operation failure. Transmission queue is full so packet was not
+ *                                  added to the transmission queue.
+ * @retval NRF_ERROR_INVALID_STATE  Operation failure. Transmittion channel was not opened by
+ *                                  @ref ser_hal_transport_open function or provided buffer was not
+ *                                  allocated by @ref ser_hal_transport_tx_pkt_alloc function.
+ * @retval NRF_ERROR_INTERNAL       Operation failure. Internal error ocurred.
+ */
+uint32_t ser_hal_transport_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes);
+
+
+/**@brief Function for freeing memory allocated for a TX packet.
+ *
+ * @note The function frees the TX memory pointed by p_buffer. Freeing a TX buffer is possible only if
+ *       the buffer was allocated by @ref ser_hal_transport_tx_pkt_alloc function and transmittion
+ *       is not in progress. When transmittion has finished, this function is automatically called by
+ *       the Serialization HAL Transport layer, so the only case when this function should be used
+ *       from outside is when a TX buffer was allocated but a transmittion has not been started
+ *       (@ref ser_hal_transport_tx_pkt_send function has not been called).
+ *
+ * @param[in] p_buffer    Pointer to the beginning of a buffer that has been allocated by
+ *                        @ref ser_hal_transport_tx_pkt_alloc function.
+ *
+ * @retval NRF_SUCCESS              Operation success. Memory was freed.
+ * @retval NRF_ERROR_NULL           Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_ADDR   Operation failure. Not a valid pointer (provided address is not
+ *                                  the starting address of a buffer managed by HAL Transport layer).
+ * @retval NRF_ERROR_INVALID_STATE  Operation failure. Freeing a TX buffer is possible only if the
+ *                                  buffer was allocated by @ref ser_hal_transport_tx_pkt_alloc
+ *                                  function and transmittion is not in progress.
+ */
+uint32_t ser_hal_transport_tx_pkt_free(uint8_t * p_buffer);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SER_HAL_TRANSPORT_H__ */
+/** @} */

COMPONENTS/serialization/common/transport/ser_phy/config/ser_config_5W_app.h

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+#ifndef SER_CONFIG_5W_APP_H__
+#define SER_CONFIG_5W_APP_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SER_CONFIG_APP_H__ */

COMPONENTS/serialization/common/transport/ser_phy/config/ser_phy_config_app.h

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+#ifndef SER_CONFIG_APP_HAL_NRF51_H__
+#define SER_CONFIG_APP_HAL_NRF51_H__
+
+#include "boards.h"
+#include "ser_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(SPI_MASTER_0_ENABLE)
+#define SER_PHY_SPI_MASTER SPI_MASTER_0
+#endif
+#if defined(SPI_MASTER_1_ENABLE)
+#define SER_PHY_SPI_MASTER SPI_MASTER_1
+#endif
+#if defined(SPI_MASTER_2_ENABLE)
+#define SER_PHY_SPI_MASTER SPI_MASTER_2
+#endif
+
+#if (defined(SPI0_ENABLED) && (SPI0_ENABLED == 1)) || defined(SPI_MASTER_0_ENABLE)
+
+#define SER_PHY_SPI_MASTER_INSTANCE             NRF_DRV_SPI_INSTANCE(0)
+#define SER_PHY_SPI_MASTER_PIN_SCK              SER_APP_SPIM0_SCK_PIN
+#define SER_PHY_SPI_MASTER_PIN_MISO             SER_APP_SPIM0_MISO_PIN
+#define SER_PHY_SPI_MASTER_PIN_MOSI             SER_APP_SPIM0_MOSI_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_SELECT     SER_APP_SPIM0_SS_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST    SER_APP_SPIM0_REQ_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_READY      SER_APP_SPIM0_RDY_PIN
+
+#elif (defined(SPI1_ENABLED) && (SPI1_ENABLED == 1)) || defined(SPI_MASTER_1_ENABLE)
+
+#define SER_PHY_SPI_MASTER_INSTANCE             NRF_DRV_SPI_INSTANCE(1)
+#define SER_PHY_SPI_MASTER_PIN_SCK              SER_APP_SPIM1_SCK_PIN
+#define SER_PHY_SPI_MASTER_PIN_MISO             SER_APP_SPIM1_MISO_PIN
+#define SER_PHY_SPI_MASTER_PIN_MOSI             SER_APP_SPIM1_MOSI_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_SELECT     SER_APP_SPIM1_SS_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST    SER_APP_SPIM1_REQ_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_READY      SER_APP_SPIM1_RDY_PIN
+
+#elif (defined(SPI2_ENABLED) && (SPI2_ENABLED == 1)) || defined(SPI_MASTER_2_ENABLE)
+
+#define SER_PHY_SPI_MASTER_INSTANCE             NRF_DRV_SPI_INSTANCE(2)
+#define SER_PHY_SPI_MASTER_PIN_SCK              SER_APP_SPIM2_SCK_PIN
+#define SER_PHY_SPI_MASTER_PIN_MISO             SER_APP_SPIM2_MISO_PIN
+#define SER_PHY_SPI_MASTER_PIN_MOSI             SER_APP_SPIM2_MOSI_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_SELECT     SER_APP_SPIM2_SS_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST    SER_APP_SPIM2_REQ_PIN
+#define SER_PHY_SPI_MASTER_PIN_SLAVE_READY      SER_APP_SPIM2_RDY_PIN
+
+#endif
+
+#define CONN_CHIP_RESET_PIN_NO                  SER_CONN_CHIP_RESET_PIN /**< Pin used for reseting the connectivity. */
+
+/* UART configuration */
+#define UART_IRQ_PRIORITY                       APP_IRQ_PRIORITY_MID
+#define SER_PHY_UART_RX                         SER_APP_RX_PIN
+#define SER_PHY_UART_TX                         SER_APP_TX_PIN
+#define SER_PHY_UART_CTS                        SER_APP_CTS_PIN
+#define SER_PHY_UART_RTS                        SER_APP_RTS_PIN
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //SER_CONFIG_APP_HAL_NRF51_H__

COMPONENTS/serialization/common/transport/ser_phy/config/ser_phy_config_conn.h

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+#ifndef SER_PHY_CONFIG_CONN_NRF51_H__
+#define SER_PHY_CONFIG_CONN_NRF51_H__
+
+#include "boards.h"
+#include "ser_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***********************************************************************************************//**
+ * SER_PHY layer configuration.
+ **************************************************************************************************/
+#define SER_PHY_SPI_PPI_RDY_CH                  0
+#define SER_PHY_SPI_GPIOTE_RDY_CH               0
+
+#define SER_PHY_SPI_SLAVE_INSTANCE              1
+
+#define SER_PHY_SPI_SLAVE_REQ_PIN               SER_CON_SPIS_REQ_PIN
+#define SER_PHY_SPI_SLAVE_RDY_PIN               SER_CON_SPIS_RDY_PIN
+#define SER_PHY_SPI_SLAVE_SCK_PIN               SER_CON_SPIS_SCK_PIN
+#define SER_PHY_SPI_SLAVE_MISO_PIN              SER_CON_SPIS_MISO_PIN
+#define SER_PHY_SPI_SLAVE_MOSI_PIN              SER_CON_SPIS_MOSI_PIN
+#define SER_PHY_SPI_SLAVE_SS_PIN                SER_CON_SPIS_CSN_PIN
+
+/* UART configuration */
+#define UART_IRQ_PRIORITY                       APP_IRQ_PRIORITY_LOWEST
+
+#define SER_PHY_UART_RX                         SER_CON_RX_PIN
+#define SER_PHY_UART_TX                         SER_CON_TX_PIN
+#define SER_PHY_UART_CTS                        SER_CON_CTS_PIN
+#define SER_PHY_UART_RTS                        SER_CON_RTS_PIN
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //SER_PHY_CONFIG_CONN_NRF51_H__

COMPONENTS/serialization/common/transport/ser_phy/config/ser_phy_debug_app.h

@@ -0,0 +1,199 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+#ifndef SER_PHY_DEBUG_APP_H__
+#define SER_PHY_DEBUG_APP_H__
+
+#ifndef SER_PHY_DEBUG_APP_ENABLE
+
+#define DEBUG_EVT_SPI_MASTER_RAW_REQUEST(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_READY(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_DONE(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_API_CALL(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_READY_EDGE(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_REQUEST_EDGE(data)
+#define DEBUG_EVT_SPI_MASTER_PHY_TX_PKT_SENT(data)
+#define DEBUG_EVT_SPI_MASTER_PHY_RX_PKT_DROPPED(data)
+#define DEBUG_EVT_SPI_MASTER_PHY_RX_PKT_RECEIVED(data)
+#define DEBUG_EVT_SPI_MASTER_PHY_BUF_REQUEST(data)
+
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_GUARDED(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_PASSED(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_ABORTED(data)
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_RESTARTED(data)
+
+#else
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//Low level hardware events
+typedef enum
+{
+    SPI_MASTER_RAW_READY,
+    SPI_MASTER_RAW_REQUEST,
+    SPI_MASTER_RAW_XFER_DONE,
+    SPI_MASTER_RAW_API_CALL,
+    SPI_MASTER_RAW_READY_EDGE,
+    SPI_MASTER_RAW_REQUEST_EDGE,
+    SPI_MASTER_RAW_XFER_STARTED,
+    SPI_MASTER_RAW_XFER_GUARDED,
+    SPI_MASTER_RAW_XFER_PASSED,
+    SPI_MASTER_RAW_XFER_ABORTED,
+    SPI_MASTER_RAW_XFER_RESTARTED,
+    SPI_MASTER_PHY_TX_PKT_SENT,
+    SPI_MASTER_PHY_BUF_REQUEST,
+    SPI_MASTER_PHY_RX_PKT_RECEIVED,
+    SPI_MASTER_PHY_RX_PKT_DROPPED,
+    SPI_MASTER_EVT_MAX
+} spi_master_raw_evt_type_t;
+
+
+//Low level hardware event definition
+typedef struct
+{
+    spi_master_raw_evt_type_t  evt;
+    uint32_t                   data;
+} spi_master_raw_evt_t;
+
+typedef void (*spi_master_raw_callback_t)(spi_master_raw_evt_t event);
+
+void debug_init(spi_master_raw_callback_t spi_master_raw_evt_callback);
+
+void debug_evt(spi_master_raw_evt_type_t evt, uint32_t data);
+
+
+#define DEBUG_EVT(evt, data)    \
+do {                            \
+    debug_evt(evt, data);       \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_RAW_REQUEST(data)          \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_REQUEST, data);            \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_RAW_READY(data)            \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_READY, data);              \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_DONE(data)        \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_XFER_DONE, data);          \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_RAW_API_CALL(data)         \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_API_CALL, data);           \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_RAW_READY_EDGE(data)       \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_READY_EDGE, data);         \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_RAW_REQUEST_EDGE(data)     \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_REQUEST_EDGE, data);       \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_PHY_TX_PKT_SENT(data)      \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_PHY_TX_PKT_SENT, data);        \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_PHY_RX_PKT_DROPPED(data)   \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_PHY_RX_PKT_DROPPED, data);     \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_PHY_RX_PKT_RECEIVED(data)  \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_PHY_RX_PKT_RECEIVED, data);    \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_MASTER_PHY_BUF_REQUEST(data)      \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_PHY_BUF_REQUEST, data);        \
+} while (0);
+
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_GUARDED(data)     \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_XFER_GUARDED, data);       \
+} while (0);
+
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_PASSED(data)      \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_XFER_PASSED, data);        \
+} while (0);
+
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_ABORTED(data)     \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_XFER_ABORTED, data);       \
+} while (0);
+
+#define DEBUG_EVT_SPI_MASTER_RAW_XFER_RESTARTED(data)   \
+do {                                                    \
+    DEBUG_EVT(SPI_MASTER_RAW_XFER_RESTARTED, data);     \
+} while (0);
+
+
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //SER_PHY_DEBUG_APP_H__

COMPONENTS/serialization/common/transport/ser_phy/config/ser_phy_debug_conn.h

@@ -0,0 +1,167 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+#ifndef SER_PHY_DEBUG_CONN_H__
+#define SER_PHY_DEBUG_CONN_H__
+
+#ifndef SER_PHY_DEBUG_CONN_ENABLE
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_RX_XFER_DONE(data);
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_TX_XFER_DONE(data);
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(data);
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_REQ_SET(data);
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_REQ_CLEARED(data);
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_BUF_REQUEST(data);
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_PKT_RECEIVED(data);
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_PKT_DROPPED(data);
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_PKT_SENT(data);
+
+#else
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// low level hardware event types
+typedef enum
+{
+    SPI_SLAVE_RAW_BUFFERS_SET,
+    SPI_SLAVE_RAW_RX_XFER_DONE,
+    SPI_SLAVE_RAW_TX_XFER_DONE,
+    SPI_SLAVE_RAW_REQ_SET,
+    SPI_SLAVE_RAW_REQ_CLEARED,
+    SPI_SLAVE_PHY_BUF_REQUEST,
+    SPI_SLAVE_PHY_PKT_SENT,
+    SPI_SLAVE_PHY_PKT_RECEIVED,
+    SPI_SLAVE_PHY_PKT_DROPPED,
+    SPI_SLAVE_RAW_EVT_TYPE_MAX
+} spi_slave_raw_evt_type_t;
+
+// low level hardware event definition
+typedef struct
+{
+    spi_slave_raw_evt_type_t  evt_type;
+    uint32_t                  data;
+} spi_slave_raw_evt_t;
+
+typedef void (*spi_slave_raw_callback_t)(spi_slave_raw_evt_t event);
+
+void debug_init(spi_slave_raw_callback_t spi_slave_raw_evt_callback);
+
+void debug_evt(spi_slave_raw_evt_type_t evt_type, uint32_t data);
+
+#define DEBUG_EVT(evt, data)    \
+do {                            \
+    debug_evt(evt, data);       \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_RX_XFER_DONE(data)  \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_RAW_RX_XFER_DONE, data);    \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_TX_XFER_DONE(data)  \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_RAW_TX_XFER_DONE, data);    \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(data)   \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_RAW_BUFFERS_SET, data);     \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_REQ_SET(data)       \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_RAW_REQ_SET, data);         \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_RAW_REQ_CLEARED(data)   \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_RAW_REQ_CLEARED, data);     \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_BUF_REQUEST(data)   \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_PHY_BUF_REQUEST, data);     \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_PKT_RECEIVED(data)  \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_PHY_PKT_RECEIVED, data);    \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_PKT_DROPPED(data)   \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_PHY_PKT_DROPPED, data);     \
+} while (0);
+
+
+#define DEBUG_EVT_SPI_SLAVE_PHY_PKT_SENT(data)      \
+do {                                                \
+    DEBUG_EVT(SPI_SLAVE_PHY_PKT_SENT, data);        \
+} while (0);
+
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //SER_PHY_DEBUG_CONN_H__

COMPONENTS/serialization/common/transport/ser_phy/ser_phy.c

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2014 - 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 "ser_phy.h"
+#include "app_error.h"
+
+
+__weak uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
+{
+    /* A function stub. Function should be implemented according to ser_phy.h API. */
+    APP_ERROR_CHECK_BOOL(false);
+
+    return NRF_SUCCESS;
+}
+
+__weak uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    /* A function stub. Function should be implemented according to ser_phy.h API. */
+    APP_ERROR_CHECK_BOOL(false);
+
+    return NRF_SUCCESS;
+}
+
+__weak uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer)
+{
+    /* A function stub. Function should be implemented according to ser_phy.h API. */
+    APP_ERROR_CHECK_BOOL(false);
+
+    return NRF_SUCCESS;
+}
+
+__weak void ser_phy_close(void)
+{
+    /* A function stub. Function should be implemented according to ser_phy.h API. */
+    APP_ERROR_CHECK_BOOL(false);
+}
+
+
+__weak void ser_phy_interrupts_enable(void)
+{
+    /* A function stub. Function should be implemented according to ser_phy.h API. */
+    APP_ERROR_CHECK_BOOL(false);
+}
+
+
+__weak void ser_phy_interrupts_disable(void)
+{
+    /* A function stub. Function should be implemented according to ser_phy.h API. */
+    APP_ERROR_CHECK_BOOL(false);
+}
+
+

COMPONENTS/serialization/common/transport/ser_phy/ser_phy.h

@@ -0,0 +1,297 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/** @file
+ *
+ * @defgroup ser_phy Serialization PHY
+ * @{
+ * @ingroup ble_sdk_lib_serialization
+ *
+ * @brief   @tagAPI52832 PHY layer for serialization.
+ *
+ * @details Here you can find declarations of functions and definitions of data structures and
+ *          identifiers (typedef enum) used as API of the serialization PHY layer.
+ *
+ * \par Rationale
+ * Each specific PHY layer (SPI, I2C, UART, low power UART etc.) should provide the same API. This
+ * allows the layer above (the HAL Transport layer), which is responsible for controlling the PHY
+ * layer, memory management, crc, retransmission etc., to be hardware independent.
+ *
+ *
+ * \par Interlayer communication and control
+ * The PHY layer is controlled by the HAL Transport layer by calling functions declared in this
+ * file.
+ * The PHY layer communicates events to the HAL Transport layer by calling a callback function.
+ * A handler to this function is passed in the @ref ser_phy_open function. This callback function
+ * should be called with parameter of type @ref ser_phy_evt_t, filled accordingly to an event to be
+ * passed. Types of supported events are defined in @ref ser_phy_evt_type_t.
+ * For example, to pass an event indicating that RX packet has been successfully received, first a
+ * struct of type @ref ser_phy_evt_t has to be filled:
+ * @code
+ * ser_phy_evt_t phy_evt;
+ * phy_evt.evt_type = SER_PHY_EVT_RX_PKT_RECEIVED;
+ * phy_evt.evt_params.rx_pkt_received.p_buffer = (pointer to the RX buffer);
+ * phy_evt.evt_params.rx_pkt_received.num_of_bytes = (number of received bytes);
+ * @endcode
+ * , and then the callback function has to be called:
+ * @code
+ * events_handler(phy_evt);
+ * @endcode
+ * All functions declared in this file are obligatory to implement. Some events specified in 
+ * @ref ser_phy_evt_type_t are optional to implement.
+ *
+ * \par Transmitting a packet
+ * Each PHY layer is responsible for adding the PHY header to a packet to be sent. This header
+ * consists of a 16-bit field that carries the packet length (the uint16_encode function defined in
+ * app_util.h should be used to ensure endianness independence). A pointer to a packet to be sent
+ * and length of the packet are parameters of the @ref ser_phy_tx_pkt_send function. When a packet
+ * has been transmitted, an event of type @ref SER_PHY_EVT_TX_PKT_SENT should be emitted.
+ *
+ * \image html ser_phy_transport_tx.svg "TX - interlayer communication"
+ *
+ *
+ * \par Receiving a packet
+ * The PHY layer should be able to store only the PHY header (16-bit field carrying the packet
+ * length). After the PHY header has been received, the transmission is stopped and the PHY
+ * layer has to send a request to the HAL Transport layer for memory to store the packet - an event
+ * of type @ref SER_PHY_EVT_RX_BUF_REQUEST with event parameters defined in
+ * @ref ser_phy_evt_rx_buf_request_params_t (the uint16_decode function defined in app_util.h should
+ * be used for header decoding to ensure endianness independence). The transmission should be
+ * resumed when the @ref ser_phy_rx_buf_set function has been called.
+ *
+ * When the @ref ser_phy_rx_buf_set function parameter equals NULL, it means that there is not
+ * enough memory to store the packet, however the packet will be received to dummy location to
+ * ensure continuous communication. After receiving has finished, an event of type
+ * @ref SER_PHY_EVT_RX_PKT_DROPPED is generated.
+ *
+ * \image html ser_phy_transport_rx_dropped.svg "RX dropping - interlayer communication"
+ *
+ * When the @ref ser_phy_rx_buf_set function parameter is different than NULL, the packet is
+ * received to a buffer pointed by it. After receiving has finished, an event of type
+ * @ref SER_PHY_EVT_RX_PKT_RECEIVED is generated with event parameters defined in
+ * @ref ser_phy_evt_rx_pkt_received_params_t.
+ *
+ * \image html ser_phy_transport_rx_received.svg "RX - interlayer communication"
+ *
+ *
+ * \par PHY layer errors
+ * PHY layer errors can be signaled by an event of type @ref SER_PHY_EVT_RX_OVERFLOW_ERROR or
+ * @ref SER_PHY_EVT_TX_OVERREAD_ERROR or @ref SER_PHY_EVT_HW_ERROR with event parameters defined in
+ * @ref ser_phy_evt_hw_error_params_t.
+ *
+ */
+
+#ifndef SER_PHY_H__
+#define SER_PHY_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@brief Serialization PHY module event types. */
+typedef enum
+{
+    SER_PHY_EVT_TX_PKT_SENT = 0,   /**< Obligatory to implement. An event indicating that a TX packet
+                                    *   has been transmitted. */
+    SER_PHY_EVT_RX_BUF_REQUEST,    /**< Obligatory to implement. An event indicating that the PHY layer
+                                    *   needs a buffer for an RX packet. The PHY flow should be blocked
+                                    *   until the @ref ser_phy_rx_buf_set function is called. */
+    SER_PHY_EVT_RX_PKT_RECEIVED,   /**< Obligatory to implement. An event indicating that an RX packet
+                                    *   has been successfully received. */
+    SER_PHY_EVT_RX_PKT_DROPPED,    /**< Obligatory to implement. An event indicating that the RX packet
+                                    *   receiving has been finished but the packet was discarded because
+                                    *   it was longer than available the buffer. */
+
+    SER_PHY_EVT_RX_OVERFLOW_ERROR, /**< Optional to implement. An event indicating that more
+                                    *   information has been transmitted than the PHY module could
+                                    *   handle. */
+    SER_PHY_EVT_TX_OVERREAD_ERROR, /**< Optional to implement. An event indicating that the PHY module
+                                    *   was forced to transmit more information than possessed. */
+    SER_PHY_EVT_HW_ERROR,          /**< Optional to implement. An event indicating a hardware error
+                                    *   in the PHY module.  */
+    SER_PHY_EVT_TYPE_MAX           /**< Enumeration upper bound. */
+} ser_phy_evt_type_t;
+
+
+/**@brief A struct containing parameters of event of type @ref SER_PHY_EVT_RX_BUF_REQUEST. */
+typedef struct
+{
+    uint16_t num_of_bytes;  /**< Length of a buffer in octets that the layer above the PHY module should
+                             *   deliver, so that the PHY module can receive a packet. */
+} ser_phy_evt_rx_buf_request_params_t;
+
+
+/**@brief A struct containing parameters of event of type @ref SER_PHY_EVT_RX_PKT_RECEIVED. */
+typedef struct
+{
+    uint8_t * p_buffer;     /**< Pointer to a buffer containing the received packet. */
+    uint16_t  num_of_bytes; /**< Length of the received packet in octets. */
+} ser_phy_evt_rx_pkt_received_params_t;
+
+
+/**@brief A struct containing parameters of event of type @ref SER_PHY_EVT_HW_ERROR. */
+typedef struct
+{
+    uint32_t error_code; /**< Hardware error code - specific for a microcontroller. */
+    uint8_t * p_buffer;  /**< Pointer to the buffer that was processed when error occured. */
+} ser_phy_evt_hw_error_params_t;
+
+
+/**@brief A struct containing events from a Serialization PHY module.
+ *
+ * @note  Some events do not have parameters, then whole information is contained in the evt_type.
+ */
+typedef struct
+{
+    ser_phy_evt_type_t                       evt_type; /**< Type of event. */
+
+    union  /**< Union alternative identified by evt_type in enclosing struct. */
+    {
+        /** Parameters of event of type @ref SER_PHY_EVT_RX_BUF_REQUEST. */
+        ser_phy_evt_rx_buf_request_params_t  rx_buf_request;
+        /** Parameters of event of type @ref SER_PHY_EVT_RX_PKT_RECEIVED. */
+        ser_phy_evt_rx_pkt_received_params_t rx_pkt_received;
+        /** Parameters of the event of type @ref SER_PHY_EVT_HW_ERROR. */
+        ser_phy_evt_hw_error_params_t        hw_error;
+    } evt_params;
+} ser_phy_evt_t;
+
+
+/**@brief A type of generic callback function handler to be used by all PHY module events.
+ *
+ * @param[in] event    Serialization PHY module event.
+ */
+typedef void (*ser_phy_events_handler_t)(ser_phy_evt_t event);
+
+
+/**@brief Function for opening and initializing the PHY module.
+ *
+ * @note  The function initializes hardware and internal module states, and registers callback
+ *        function to be used by all PHY module events.
+ *
+ * @warning If the function has been already called, the function @ref ser_phy_close has to be
+ *          called before ser_phy_open can be called again.
+ *
+ * @param[in] events_handler    Generic callback function handler to be used by all PHY module
+ *                              events.
+ *
+ * @retval NRF_SUCCESS                Operation success.
+ * @retval NRF_ERROR_INVALID_STATE    Operation failure. The function has been already called.
+ *                                    To call it again, the function @ref ser_phy_close has to be
+ *                                    called first.
+ * @retval NRF_ERROR_NULL             Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_PARAM    Operation failure. Hardware initialization parameters are not
+ *                                    supported.
+ */
+uint32_t ser_phy_open(ser_phy_events_handler_t events_handler);
+
+
+/**@brief Function for transmitting a packet.
+ *
+ * @note  The function adds a packet pointed by p_buffer parameter to a transmission queue and
+ *        schedules generation of an event of type @ref SER_PHY_EVT_TX_PKT_SENT upon transmission
+ *        completion.
+ *
+ * @param[in] p_buffer        Pointer to a buffer to transmit.
+ * @param[in] num_of_bytes    Number of octets to transmit. Must be more than 0.
+ *
+ * @retval NRF_SUCCESS                Operation success. Packet was added to the transmission queue
+ *                                    and event will be send upon transmission completion.
+ * @retval NRF_ERROR_NULL             Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_PARAM    Operation failure. The num_of_bytes parameter equal to 0.
+ * @retval NRF_ERROR_BUSY             Operation failure. Transmitting of a packet in progress.
+ */
+uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes);
+
+
+/**@brief Function for setting an RX buffer and enabling reception of data (the PHY flow).
+ *
+ * @note The function has to be called as a response to an event of type
+ *       @ref SER_PHY_EVT_RX_BUF_REQUEST. The function sets an RX buffer and enables reception of
+ *       data (enables the PHY flow).
+ *       Size of a buffer pointed by the p_buffer parameter should be at least equal to the
+ *       num_of_bytes parameter passed within the event (@ref ser_phy_evt_rx_buf_request_params_t),
+ *       or p_buffer should be equal to NULL if there is not enough memory.
+ *       When p_buffer is different from NULL and num_of_bytes octets have been received, an event of
+ *       type @ref SER_PHY_EVT_RX_PKT_RECEIVED is generated
+ *       (@ref ser_phy_evt_rx_pkt_received_params_t).
+ *       When p_buffer is equal to NULL, data is received to dummy location to ensure continuous
+ *       communication. Then, if num_of_bytes octets have been received, an event of type
+ *       @ref SER_PHY_EVT_RX_PKT_DROPPED is generated.
+ *
+ * @param[in] p_buffer    Pointer to an RX buffer in which to receive.
+ *
+ * @retval NRF_SUCCESS                Operation success.
+ * @retval NRF_ERROR_INVALID_STATE    Operation failure. A buffer was set without request.
+ */
+uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer);
+
+
+/**@brief Function for closing the PHY module.
+ *
+ * @note  The function disables hardware, resets internal module states, and unregisters the events
+ *        callback function.
+ */
+void ser_phy_close(void);
+
+
+/**@brief Function for enabling the PHY module interrupts.
+ *
+ * @note  The function enables all interrupts that are used by the PHY module (and only those).
+ */
+void ser_phy_interrupts_enable(void);
+
+
+/**@brief Function for disabling the PHY module interrupts.
+ *
+ * @note  The function disables all interrupts that are used by the PHY module (and only those).
+ */
+void ser_phy_interrupts_disable(void);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SER_PHY_H__ */
+/** @} */

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_hci.h

@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/** @file
+ *
+ * @defgroup ser_phy_hci HCI Serialization PHY
+ * @{
+ * @ingroup ble_sdk_lib_serialization
+ *
+ * @brief   @tagAPI52832 HCI PHY layer for serialization.
+ *
+ * @details This file contains declarations of functions and definitions of data structures and
+ *          identifiers (typedef enum) used as API of the serialization HCI PHY layer.
+ *
+ *
+ */
+
+#ifndef SER_PHY_HCI_H__
+#define SER_PHY_HCI_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@brief Serialization PHY HCI module events types. */
+typedef enum
+{
+    SER_PHY_HCI_SLIP_EVT_PKT_SENT = 0,      /**< An event indicating that packet has been transmitted. */
+    SER_PHY_HCI_SLIP_EVT_ACK_SENT,          /**< An event indicating that ack packet has been transmitted. */
+    SER_PHY_HCI_SLIP_EVT_PKT_RECEIVED,      /**< An event indicating that packet has been received.  */
+    SER_PHY_HCI_SLIP_EVT_HW_ERROR,          /**< An event indicating a hardware error in PHY HCI module.  */
+    SER_PHY_HCI_SLIP_EVT_TYPE_MAX           /**< Enumeration upper bound. */
+} ser_phy_hci_slip_evt_type_t;
+
+/**@brief Struct representing a PHY HCI packet. */
+typedef struct
+{
+    uint8_t * p_buffer;     /**< Pointer to a buffer containing a packet. */
+    uint16_t  num_of_bytes; /**< Length of a packet in octets. */
+} ser_phy_hci_pkt_params_t;
+
+
+/**@brief Struct containing parameters of event of type @ref SER_PHY_HCI_SLIP_EVT_HW_ERROR. */
+typedef struct
+{
+    uint32_t error_code; /**< Hardware error code - specific for a microcontroller. */
+} ser_phy_hci_evt_hw_error_params_t;
+
+
+/**@brief Struct containing events from the Serialization PHY module.
+ *
+ * @note  Some events do not have parameters, then the whole information is contained in the evt_type.
+ */
+typedef struct
+{
+    ser_phy_hci_slip_evt_type_t            evt_type; /**< Type of an event. */
+    union  /**< Union alternative identified by evt_type in the enclosing struct. */
+    {
+        /** Parameters of event of type @ref SER_PHY_HCI_SLIP_EVT_PKT_RECEIVED. */
+        ser_phy_hci_pkt_params_t             received_pkt;
+        /** Parameters of event of type @ref SER_PHY_HCI_SLIP_EVT_HW_ERROR. */
+        ser_phy_hci_evt_hw_error_params_t    hw_error;
+    } evt_params;
+} ser_phy_hci_slip_evt_t;
+
+
+/**@brief Type of generic callback function handler to be used by all PHY HCI events.
+ *
+ * @param[in] event    Serialization PHY HCI module event.
+ */
+typedef void (*ser_phy_hci_slip_event_handler_t)(ser_phy_hci_slip_evt_t *p_event);
+
+/**@brief Function for opening and initializing a HCI SLIP PHY module.
+ *
+ * @note  The function initializes hardware and internal module states and registers callback
+ *        function to be used by all PHY HCI module events.
+ *
+ * @warning If the function has been already called, the function @ref ser_phy_hci_slip_close has to be
+ *          called before ser_phy_hci_slip_open can be called again.
+ *
+ * @param[in] events_handler    Generic callback function handler to be used by all PHY HCI module
+ *                              events.
+ *
+ * @retval NRF_SUCCESS                Operation success.
+ * @retval NRF_ERROR_INVALID_STATE    Operation failure. The function has been already called.
+ *                                    To call it again, the function @ref ser_phy_hci_slip_close has to
+ *                                    be called first.
+ * @retval NRF_ERROR_NULL             Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_PARAM    Operation failure. Hardware initialization parameters are not
+ *                                    supported.
+ */
+uint32_t ser_phy_hci_slip_open(ser_phy_hci_slip_event_handler_t events_handler);
+
+
+/**@brief A function for transmitting a HCI SLIP packet.
+ *
+ * @note  The function adds a packet pointed by p_buffer parameter to a transmission queue and
+ *        schedules generation of an event of type @ref SER_PHY_HCI_SLIP_EVT_PKT_SENT upon transmission
+ *        completion.
+ *
+ * @param[in] p_header  Pointer to ser_phy_hci_pkt_params_t structure representing packet header.
+ * @param[in] p_payload Pointer to ser_phy_hci_pkt_params_t structure representing packet payload.
+ * @param[in] p_crc     Pointer to ser_phy_hci_pkt_params_t structure representing packet crc.
+ *
+ * @retval NRF_SUCCESS                Operation success. Packet was added to the transmission queue
+ *                                    and event will be sent upon transmission completion.
+ * @retval NRF_ERROR_NULL             Operation failure. NULL pointer supplied in p_header parameter.
+ *                                    NULL pointer is allowed for p_payload and p_crc parameters.
+ * @retval NRF_ERROR_INVALID_PARAM    Operation failure. Number of bytes to be sent equals 0.
+ * @retval NRF_ERROR_BUSY             Operation failure. Transmitting of a packet in progress.
+ */
+uint32_t ser_phy_hci_slip_tx_pkt_send(const ser_phy_hci_pkt_params_t * p_header,
+                                      const ser_phy_hci_pkt_params_t * p_payload,
+                                      const ser_phy_hci_pkt_params_t * p_crc);
+
+
+/**@brief A function for freeing an RX buffer.
+ *
+ * @note The function has to be called as a response to event @ref SER_PHY_HCI_SLIP_EVT_PKT_RECEIVED
+ *       when an RX packet has been processed. The function frees the RX buffer and therefore enables
+ *       reception of next incoming data.
+
+ * @param[in] p_buffer    Pointer to an RX buffer which must be freed.
+ *
+ * @retval NRF_SUCCESS                Operation success.
+ * @retval NRF_ERROR_NULL             Operation failure. NULL pointer supplied.
+ * @retval NRF_ERROR_INVALID_STATE    Operation failure. A buffer was already free.
+ */
+uint32_t ser_phy_hci_slip_rx_buf_free(uint8_t * p_buffer);
+
+
+/**@brief A function for closing a PHY HCI module.
+ *
+ * @note  The function disables hardware, resets internal module states, and unregisters the events
+ *        callback function.
+ */
+void ser_phy_hci_slip_close(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SER_PHY_HCI_H__ */
+/** @} */

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_hci_slip.c

@@ -0,0 +1,639 @@
+/**
+ * Copyright (c) 2014 - 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 <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include "nrf_error.h"
+#include "nrf_gpio.h"
+#include "app_uart.h"
+#include "ser_phy_hci.h"
+#include "app_error.h"
+#include "app_util_platform.h"
+#include "nrf_soc.h"
+
+#ifdef SER_CONNECTIVITY
+#include "ser_phy_config_conn.h"
+#else
+#include "ser_phy_config_app.h"
+#endif /* SER_CONNECTIVITY */
+
+#include "ser_config.h"
+#define APP_SLIP_END     0xC0 /**< SLIP code for identifying the beginning and end of a packet frame.. */
+#define APP_SLIP_ESC     0xDB /**< SLIP escape code. This code is used to specify that the following character is specially encoded. */
+#define APP_SLIP_ESC_END 0xDC /**< SLIP special code. When this code follows 0xDB, this character is interpreted as payload data 0xC0.. */
+#define APP_SLIP_ESC_ESC 0xDD /**< SLIP special code. When this code follows 0xDB, this character is interpreted as payload data 0xDB. */
+
+#define HDR_SIZE 4
+#define CRC_SIZE 2
+#define PKT_SIZE (SER_HAL_TRANSPORT_MAX_PKT_SIZE + HDR_SIZE + CRC_SIZE)
+
+static const app_uart_comm_params_t comm_params =
+{
+    .rx_pin_no  = SER_PHY_UART_RX,
+    .tx_pin_no  = SER_PHY_UART_TX,
+    .rts_pin_no = SER_PHY_UART_RTS,
+    .cts_pin_no = SER_PHY_UART_CTS,
+    // Below values are defined in ser_config.h common for application and connectivity
+    .flow_control = SER_PHY_UART_FLOW_CTRL,
+    .use_parity   = SER_PHY_UART_PARITY,
+    .baud_rate    = SER_PHY_UART_BAUDRATE
+};
+
+static uint8_t m_small_buffer[HDR_SIZE];
+static uint8_t m_big_buffer[PKT_SIZE];
+
+static uint8_t * mp_small_buffer = NULL;
+static uint8_t * mp_big_buffer   = NULL;
+static uint8_t * mp_buffer       = NULL;
+
+static ser_phy_hci_pkt_params_t m_header;
+static ser_phy_hci_pkt_params_t m_payload;
+static ser_phy_hci_pkt_params_t m_crc;
+static ser_phy_hci_pkt_params_t m_header_pending;
+static ser_phy_hci_pkt_params_t m_payload_pending;
+static ser_phy_hci_pkt_params_t m_crc_pending;
+
+static ser_phy_hci_slip_evt_t           m_ser_phy_hci_slip_event;
+static ser_phy_hci_slip_event_handler_t m_ser_phy_hci_slip_event_handler; /**< Event handler for upper layer */
+
+static bool    m_other_side_active = false; /**< Flag indicating that the other side is running */
+static uint8_t m_rx_byte;                   /**< Rx byte passed from low-level driver */
+
+static bool m_rx_escape = false;
+static bool m_tx_escape = false;
+
+static bool m_tx_busy = false; /**< Flag indicating that currently some transmission is ongoing */
+
+static uint32_t                   m_tx_index;
+static uint32_t                   m_rx_index;
+static ser_phy_hci_pkt_params_t * mp_data = NULL;
+
+/* Function declarations */
+static uint32_t ser_phy_hci_tx_byte(void);
+static bool     slip_decode(uint8_t * p_received_byte);
+static void     ser_phi_hci_rx_byte(uint8_t rx_byte);
+// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+__STATIC_INLINE void callback_hw_error(uint32_t error_src)
+{
+    m_ser_phy_hci_slip_event.evt_type = SER_PHY_HCI_SLIP_EVT_HW_ERROR;
+
+    // Pass error source to upper layer
+    m_ser_phy_hci_slip_event.evt_params.hw_error.error_code = error_src;
+    m_ser_phy_hci_slip_event_handler(&m_ser_phy_hci_slip_event);
+}
+
+
+__STATIC_INLINE void slip_encode(void)
+{
+    switch (mp_data->p_buffer[m_tx_index])
+    {
+        case APP_SLIP_END:
+            m_tx_escape = true;
+            (void)app_uart_put(APP_SLIP_ESC);
+            break;
+
+        case APP_SLIP_ESC:
+            m_tx_escape = true;
+            (void)app_uart_put(APP_SLIP_ESC);
+            break;
+
+        default:
+            (void)app_uart_put(mp_data->p_buffer[m_tx_index]);
+            m_tx_index++;
+            break;
+    }
+}
+
+
+__STATIC_INLINE bool check_pending_tx()
+{
+    bool tx_continue = false;
+
+    if (m_header_pending.p_buffer != NULL)
+    {
+        m_header  = m_header_pending;
+        m_payload = m_payload_pending;
+        m_crc     = m_crc_pending;
+
+        m_header_pending.p_buffer      = NULL;
+        m_header_pending.num_of_bytes  = 0;
+        m_payload_pending.p_buffer     = NULL;
+        m_payload_pending.num_of_bytes = 0;
+        m_crc_pending.p_buffer         = NULL;
+        m_crc_pending.num_of_bytes     = 0;
+
+        m_tx_index  = 0; // may be also done in ser_phy_hci_tx_byte???
+        tx_continue = true;
+
+        /* Start sending pending packet */
+        (void)ser_phy_hci_tx_byte();
+    }
+
+    return tx_continue;
+}
+
+
+static uint32_t ser_phy_hci_tx_byte()
+{
+    /* Flags informing about actually transmited part of packet*/
+    static bool header  = false;
+    static bool payload = false;
+    static bool crc     = false;
+
+    static bool ack_end    = false;
+    static bool packet_end = false;
+
+    if (ack_end == true)
+    {
+        ack_end   = false;
+        m_tx_busy = check_pending_tx();
+        /* Report end of ACK transmission*/
+        m_ser_phy_hci_slip_event.evt_type = SER_PHY_HCI_SLIP_EVT_ACK_SENT;
+        m_ser_phy_hci_slip_event_handler(&m_ser_phy_hci_slip_event);
+
+    }
+    else if (packet_end == true)
+    {
+        packet_end = false;
+        m_tx_busy  = check_pending_tx();
+        /* Report end of packet transmission*/
+        m_ser_phy_hci_slip_event.evt_type = SER_PHY_HCI_SLIP_EVT_PKT_SENT;
+        m_ser_phy_hci_slip_event_handler(&m_ser_phy_hci_slip_event);
+
+    }
+    else if ((m_tx_index == 0) && !header && !payload && !crc)
+    {
+        /* Beginning of packet - sent 0xC0*/
+        header  = true;
+        mp_data = &m_header;
+        (void)app_uart_put(APP_SLIP_END);
+    }
+    else if ((m_tx_index == mp_data->num_of_bytes) && crc == true)
+    {
+        /* End of packet - sent 0xC0*/
+        (void)app_uart_put(APP_SLIP_END);
+
+        m_crc.p_buffer = NULL;
+        crc            = false;
+        m_tx_index     = 0;
+        packet_end     = true;
+    }
+    else if ((m_tx_index == mp_data->num_of_bytes) && header == true)
+    {
+        /* End of header transmission*/
+        m_tx_index = 0;
+
+        if (m_payload.p_buffer != NULL)
+        {
+            header  = false;
+            payload = true;
+            mp_data = &m_payload;
+
+            /* Handle every character in buffer accordingly to SLIP protocol*/
+            slip_encode();
+        }
+        else
+        {
+            /* End of ACK - sent 0xC0*/
+            (void)app_uart_put(APP_SLIP_END);
+
+            header  = false;
+            ack_end = true;
+        }
+    }
+    else if ((m_tx_index == mp_data->num_of_bytes) && payload == true)
+    {
+        /* End of payload transmission*/
+        m_tx_index = 0;
+
+        if (m_crc.p_buffer != NULL)
+        {
+            m_payload.p_buffer = NULL;
+            payload            = false;
+            crc                = true;
+            mp_data            = &m_crc;
+
+            /* Handle every character in buffer accordingly to SLIP protocol*/
+            slip_encode();
+        }
+        /* CRC is not used for this packet -> finish packet transmission */
+        else
+        {
+            /* End of packet - send 0xC0*/
+            (void)app_uart_put(APP_SLIP_END);
+
+            m_payload.p_buffer = NULL;
+            payload            = false;
+            packet_end         = true;
+        }
+    }
+    else if (m_tx_escape == false)
+    {
+        /* Handle every character in buffer accordingly to SLIP protocol*/
+        slip_encode();
+    }
+    else if (m_tx_escape == true)
+    {
+        /* Send SLIP special code*/
+        m_tx_escape = false;
+
+        if (mp_data->p_buffer[m_tx_index] == APP_SLIP_END)
+        {
+            (void)app_uart_put(APP_SLIP_ESC_END);
+            m_tx_index++;
+        }
+        else
+        {
+            (void)app_uart_put(APP_SLIP_ESC_ESC);
+            m_tx_index++;
+        }
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+uint32_t ser_phy_hci_slip_tx_pkt_send(const ser_phy_hci_pkt_params_t * p_header,
+                                      const ser_phy_hci_pkt_params_t * p_payload,
+                                      const ser_phy_hci_pkt_params_t * p_crc)
+{
+    /* Block TXRDY interrupts at this point*/
+    // NRF_UART0->INTENCLR = (UART_INTENCLR_TXDRDY_Clear << UART_INTENCLR_TXDRDY_Pos);
+    CRITICAL_REGION_ENTER();
+
+    if (p_header == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    /* Check if no tx is ongoing */
+    if (!m_tx_busy)
+    {
+        m_header = *p_header;
+
+        if (p_payload != NULL)
+        {
+            m_payload = *p_payload;
+        }
+
+        if (p_crc != NULL)
+        {
+            m_crc = *p_crc;
+        }
+    }
+    /* Tx is ongoing, schedule transmission as pending */
+    else
+    {
+        if (p_crc != NULL)
+        {
+            m_crc_pending = *p_crc;
+        }
+
+        if (p_payload != NULL)
+        {
+            m_payload_pending = *p_payload;
+        }
+
+        m_header_pending = *p_header;
+    }
+
+    /* Start packet transmission only if no other tx is ongoing */
+    if (!m_tx_busy)
+    {
+        m_tx_busy = true;
+        (void)ser_phy_hci_tx_byte();
+    }
+
+    /* Enable TXRDY interrupts at this point*/
+    // NRF_UART0->INTENSET = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
+    CRITICAL_REGION_EXIT();
+    return NRF_SUCCESS;
+}
+
+
+/* Function returns false when last byte in packet is detected.*/
+static bool slip_decode(uint8_t * p_received_byte)
+{
+    switch (*p_received_byte)
+    {
+        case APP_SLIP_END:
+            return false;
+
+        case APP_SLIP_ESC:
+            m_rx_escape = true;
+            break;
+
+        case APP_SLIP_ESC_END:
+
+            if (m_rx_escape == true)
+            {
+                m_rx_escape      = false;
+                *p_received_byte = APP_SLIP_END;
+            }
+            break;
+
+        case APP_SLIP_ESC_ESC:
+
+            if (m_rx_escape == true)
+            {
+                m_rx_escape      = false;
+                *p_received_byte = APP_SLIP_ESC;
+            }
+            break;
+
+        /* Normal character - decoding not needed*/
+        default:
+            break;
+    }
+
+    return true;
+}
+
+
+static void ser_phi_hci_rx_byte(uint8_t rx_byte)
+{
+    static bool rx_sync         = false;
+    uint8_t     received_byte   = rx_byte;
+    static bool big_buff_in_use = false;
+
+    /* Test received byte for SLIP packet start: 0xC0*/
+    if (!rx_sync)
+    {
+        if (received_byte == APP_SLIP_END)
+        {
+            m_rx_index = 0;
+            rx_sync    = true;
+        }
+        return;
+    }
+
+    /* Additional check needed in case rx_sync flag was set by end of previous packet*/
+    if ((m_rx_index) == 0 && (received_byte == APP_SLIP_END))
+    {
+        return;
+    }
+
+    /* Check if small (ACK) buffer is available*/
+    if ((mp_small_buffer != NULL) && (big_buff_in_use == false))
+    {
+        if (m_rx_index == 0)
+        {
+            mp_buffer = mp_small_buffer;
+        }
+
+        /* Check if switch between small and big buffer is needed*/
+        if (m_rx_index == sizeof (m_small_buffer) /*NEW!!!*/ && received_byte != APP_SLIP_END)
+        {
+            /* Check if big (PKT) buffer is available*/
+            if (mp_big_buffer != NULL)
+            {
+                /* Switch to big buffer*/
+                memcpy(m_big_buffer, m_small_buffer, sizeof (m_small_buffer));
+                mp_buffer = m_big_buffer;
+            }
+            else
+            {
+                /* Small buffer is too small and big buffer not available - cannot continue reception*/
+                rx_sync = false;
+                return;
+            }
+        }
+
+        /* Check if big buffer is full */
+        if ((m_rx_index >= PKT_SIZE) && (received_byte != APP_SLIP_END))
+        {
+            /* Do not notify upper layer - the packet is too big and cannot be handled by slip */
+            rx_sync = false;
+            return;
+        }
+
+        /* Decode byte. Will return false when it is 0xC0 - end of packet*/
+        if (slip_decode(&received_byte))
+        {
+            /* Write Rx byte only if it is not escape char */
+            if (!m_rx_escape)
+            {
+                mp_buffer[m_rx_index++] = received_byte;
+            }
+        }
+        else
+        {
+            /* Reset pointers to signalise buffers are locked waiting for upper layer */
+            if (mp_buffer == mp_small_buffer)
+            {
+                mp_small_buffer = NULL;
+            }
+            else
+            {
+                mp_big_buffer = NULL;
+            }
+            /* Report packet reception end*/
+            m_ser_phy_hci_slip_event.evt_type =
+                SER_PHY_HCI_SLIP_EVT_PKT_RECEIVED;
+            m_ser_phy_hci_slip_event.evt_params.received_pkt.p_buffer     = mp_buffer;
+            m_ser_phy_hci_slip_event.evt_params.received_pkt.num_of_bytes = m_rx_index;
+            m_ser_phy_hci_slip_event_handler(&m_ser_phy_hci_slip_event);
+
+            rx_sync = false;
+        }
+    }
+    else if (mp_big_buffer != NULL)
+    {
+        big_buff_in_use = true;
+        mp_buffer       = mp_big_buffer;
+
+        /* Check if big buffer is full */
+        if ((m_rx_index >= PKT_SIZE) && (received_byte != APP_SLIP_END))
+        {
+            /* Do not notify upper layer - the packet is too big and cannot be handled by slip */
+            rx_sync = false;
+            return;
+        }
+
+        /* Decode byte*/
+        if (slip_decode(&received_byte))
+        {
+            /* Write Rx byte only if it is not escape char */
+            if (!m_rx_escape)
+            {
+                mp_buffer[m_rx_index++] = received_byte;
+            }
+        }
+        else
+        {
+            /* Report packet reception end*/
+            m_ser_phy_hci_slip_event.evt_type =
+                SER_PHY_HCI_SLIP_EVT_PKT_RECEIVED;
+            m_ser_phy_hci_slip_event.evt_params.received_pkt.p_buffer     = mp_buffer;
+            m_ser_phy_hci_slip_event.evt_params.received_pkt.num_of_bytes = m_rx_index;
+            m_ser_phy_hci_slip_event_handler(&m_ser_phy_hci_slip_event);
+
+            rx_sync         = false;
+            mp_big_buffer   = NULL;
+            big_buff_in_use = false;
+        }
+    }
+    else
+    {
+        /* Both buffers are not available - cannot continue reception*/
+        rx_sync = false;
+        return;
+    }
+}
+
+
+uint32_t ser_phy_hci_slip_rx_buf_free(uint8_t * p_buffer)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    if (p_buffer == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+    else if (p_buffer == m_small_buffer)
+    {
+        /* Free small buffer*/
+        if (mp_small_buffer == NULL)
+        {
+            mp_small_buffer = m_small_buffer;
+        }
+        else
+        {
+            err_code = NRF_ERROR_INVALID_STATE;
+        }
+    }
+    else if (p_buffer == m_big_buffer)
+    {
+        /* Free big buffer*/
+        if (mp_big_buffer == NULL)
+        {
+            mp_big_buffer = m_big_buffer;
+        }
+        else
+        {
+            err_code = NRF_ERROR_INVALID_STATE;
+        }
+    }
+
+    return err_code;
+}
+
+
+static void ser_phy_uart_evt_callback(app_uart_evt_t * uart_evt)
+{
+    if (uart_evt == NULL)
+    {
+        return;
+    }
+
+    switch (uart_evt->evt_type)
+    {
+        case APP_UART_COMMUNICATION_ERROR:
+
+            // Process error only if this is parity or overrun error.
+            // Break and framing error is always present when app side is not active
+            if (uart_evt->data.error_communication &
+                (UART_ERRORSRC_PARITY_Msk | UART_ERRORSRC_OVERRUN_Msk))
+            {
+                callback_hw_error(uart_evt->data.error_communication);
+            }
+            break;
+
+        case APP_UART_TX_EMPTY:
+            (void)ser_phy_hci_tx_byte();
+            break;
+
+        case APP_UART_DATA:
+
+            // After first reception disable pulldown - it was only needed before start
+            // of the other side
+            if (!m_other_side_active)
+            {
+                m_other_side_active = true;
+            }
+
+            m_rx_byte = uart_evt->data.value;
+            ser_phi_hci_rx_byte(m_rx_byte);
+            break;
+
+        default:
+            APP_ERROR_CHECK(NRF_ERROR_INTERNAL);
+            break;
+    }
+}
+
+
+uint32_t ser_phy_hci_slip_open(ser_phy_hci_slip_event_handler_t events_handler)
+{
+    uint32_t err_code;
+
+    if (events_handler == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    // Check if function was not called before
+    if (m_ser_phy_hci_slip_event_handler != NULL)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    // Configure UART and register handler
+    // uart_evt_handler is used to handle events produced by low-level uart driver
+    APP_UART_INIT(&comm_params, ser_phy_uart_evt_callback, UART_IRQ_PRIORITY, err_code);
+
+    mp_small_buffer = m_small_buffer;
+    mp_big_buffer   = m_big_buffer;
+
+    m_ser_phy_hci_slip_event_handler = events_handler;
+
+    return err_code;
+}
+
+
+void ser_phy_hci_slip_close(void)
+{
+    m_ser_phy_hci_slip_event_handler = NULL;
+    (void)app_uart_close();
+}
+

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_nohci.c

@@ -0,0 +1,383 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/**@file
+ *
+ * @defgroup ser_phy_spi_phy_driver_slave ser_phy_nrf51_spi_slave.c
+ * @{
+ * @ingroup ser_phy_spi_phy_driver_slave
+ *
+ * @brief SPI_RAW PHY slave driver.
+ */
+
+#include <stddef.h>
+#include <string.h>
+
+#include "app_error.h"
+#include "app_util.h"
+#include "app_util_platform.h"
+#include "app_timer.h"
+#include "ser_phy.h"
+#include "ser_phy_hci.h"
+#include "crc16.h"
+#include "nrf_soc.h"
+
+#include "ser_phy_debug_comm.h"
+
+static bool m_flag_nohci_init = false;
+static bool m_flag_expect_ack;
+static bool m_flag_buffer_reqested = false;
+
+static uint16_t  m_rx_packet_length;
+static uint8_t * m_p_rx_packet;
+
+static uint16_t  m_rx_pending_packet_length;
+static uint8_t * m_p_rx_pending_packet;
+
+static uint16_t  m_rx_allocated_packet_length;
+static uint8_t * m_p_rx_allocated_packet;
+
+static uint8_t * m_p_tx_packet = NULL;
+static uint16_t  m_tx_packet_length;
+
+static ser_phy_events_handler_t m_ser_phy_callback = NULL;
+
+#define PKT_HDR_SIZE 4 /**< Packet header size in number of bytes. */
+#define PKT_CRC_SIZE 2 /**< Packet CRC size in number of bytes. */
+
+static void ser_phy_nohci_assert(bool cond)
+{
+    APP_ERROR_CHECK_BOOL(cond);
+}
+
+
+static void ser_phy_event_callback(ser_phy_evt_t event)
+{
+    if (m_ser_phy_callback)
+    {
+        m_ser_phy_callback(event);
+    }
+}
+
+
+static void memory_request_callback(uint16_t size)
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_HCI_PHY_EVT_BUF_REQUEST(0);
+
+    event.evt_type                               = SER_PHY_EVT_RX_BUF_REQUEST;
+    event.evt_params.rx_buf_request.num_of_bytes = size;
+    ser_phy_event_callback(event);
+}
+
+
+static void packet_received_callback(uint8_t * pBuffer, uint16_t size)
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_HCI_PHY_EVT_RX_PKT_RECEIVED(0);
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_RECEIVED;
+    event.evt_params.rx_pkt_received.num_of_bytes = size;
+    event.evt_params.rx_pkt_received.p_buffer     = pBuffer;
+    ser_phy_event_callback(event);
+}
+
+
+static void packet_dropped_callback(void)
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_HCI_PHY_EVT_RX_PKT_DROPPED(0);
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_DROPPED;
+    ser_phy_event_callback(event);
+}
+
+
+static void packet_transmitted_callback(void)
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_HCI_PHY_EVT_TX_PKT_SENT(0);
+
+    event.evt_type = SER_PHY_EVT_TX_PKT_SENT;
+    ser_phy_event_callback(event);
+}
+
+
+static void hci_slip_event_handler(ser_phy_hci_slip_evt_t * p_event)
+{
+    if ( p_event->evt_type == SER_PHY_HCI_SLIP_EVT_PKT_SENT )
+    {
+        DEBUG_EVT_SLIP_PACKET_TXED(0);
+
+        if (!m_flag_expect_ack)
+        {
+            m_p_tx_packet = NULL;
+            packet_transmitted_callback();
+        }
+        else
+        {
+            ser_phy_nohci_assert(false); // packet was send as a ACK packet, callback should be with ACK_SENT
+        }
+
+    }
+    else if ( p_event->evt_type == SER_PHY_HCI_SLIP_EVT_ACK_SENT )
+    {
+        DEBUG_EVT_SLIP_ACK_TXED(0);
+
+        if (m_flag_expect_ack)
+        {
+            m_p_tx_packet = NULL;
+            packet_transmitted_callback();
+        }
+        else
+        {
+            ser_phy_nohci_assert(false); // packet was send as a normal packet, callback should be with PKT_SENT
+        }
+
+    }
+    else if ( p_event->evt_type == SER_PHY_HCI_SLIP_EVT_PKT_RECEIVED )
+    {
+        CRITICAL_REGION_ENTER();
+
+        if (m_p_rx_packet == NULL)
+        {
+            m_p_rx_packet                = p_event->evt_params.received_pkt.p_buffer;
+            m_rx_packet_length           = p_event->evt_params.received_pkt.num_of_bytes;
+            m_p_rx_allocated_packet      = m_p_rx_packet;
+            m_rx_allocated_packet_length = m_rx_packet_length;
+            m_flag_buffer_reqested       = true;
+            memory_request_callback(m_rx_allocated_packet_length);
+        }
+        else if (m_p_rx_pending_packet == NULL)
+        {
+            m_p_rx_pending_packet      = p_event->evt_params.received_pkt.p_buffer;
+            m_rx_pending_packet_length = p_event->evt_params.received_pkt.num_of_bytes;
+        }
+        else
+        {
+            // both buffers are not released; this is fault
+            ser_phy_nohci_assert(false);
+        }
+        CRITICAL_REGION_EXIT();
+    }
+    else
+    {
+        // no other callbacks are expected
+        ser_phy_nohci_assert(false);
+    }
+}
+
+
+/* ser_phy API function */
+void ser_phy_interrupts_enable(void)
+{
+
+    NVIC_EnableIRQ(UART0_IRQn);
+    return;
+}
+
+
+/* ser_phy API function */
+void ser_phy_interrupts_disable(void)
+{
+    NVIC_DisableIRQ(UART0_IRQn);
+    return;
+}
+
+
+/* ser_phy API function */
+uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer)
+{
+    uint32_t status = NRF_SUCCESS;
+
+    if (m_flag_buffer_reqested)
+    {
+        m_flag_buffer_reqested = false;
+
+        if (p_buffer)
+        {
+            memcpy(p_buffer, m_p_rx_allocated_packet, m_rx_allocated_packet_length);
+            packet_received_callback(p_buffer, m_rx_allocated_packet_length);
+        }
+        else
+        {
+            packet_dropped_callback();
+        }
+
+        CRITICAL_REGION_ENTER();
+
+        if (m_p_rx_allocated_packet == m_p_rx_packet && (m_p_rx_pending_packet == NULL))
+        {
+            // packet is copied and there is no pending packet
+            (void) ser_phy_hci_slip_rx_buf_free(m_p_rx_packet);
+            m_p_rx_packet           = NULL;
+            m_p_rx_allocated_packet = NULL;
+        }
+        else if (m_p_rx_allocated_packet == m_p_rx_packet && (m_p_rx_pending_packet != NULL))
+        {
+            // there is a pending packet - request memory for it
+            m_p_rx_allocated_packet      = m_p_rx_pending_packet;
+            m_rx_allocated_packet_length = m_rx_pending_packet_length;
+            m_flag_buffer_reqested       = true;
+        }
+        else if (m_p_rx_allocated_packet == m_p_rx_pending_packet )
+        {
+            // the pending packet was serviced - release both
+            m_p_rx_allocated_packet = NULL;
+            (void) ser_phy_hci_slip_rx_buf_free(m_p_rx_packet);
+            m_p_rx_packet = NULL;
+            (void) ser_phy_hci_slip_rx_buf_free(m_p_rx_pending_packet);
+            m_p_rx_pending_packet = NULL;
+        }
+        else
+        {
+            // no other calls are expected
+            ser_phy_nohci_assert(false);
+        }
+        CRITICAL_REGION_EXIT();
+
+        // request memory for a pending
+        if (m_p_rx_allocated_packet)
+        {
+            memory_request_callback(m_rx_allocated_packet_length);
+        }
+    }
+    else
+    {
+        status = NRF_ERROR_BUSY;
+    }
+    return status;
+}
+
+
+/* ser_phy API function */
+uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    uint32_t status = NRF_SUCCESS;
+    uint32_t err_code;
+
+    if ( p_buffer == NULL || num_of_bytes == 0)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    if ( m_p_tx_packet == NULL)
+    {
+        m_tx_packet_length = num_of_bytes;
+        m_p_tx_packet      = (uint8_t *)p_buffer;
+
+        if (m_tx_packet_length <= PKT_HDR_SIZE + PKT_CRC_SIZE)
+        {
+            ser_phy_hci_pkt_params_t pkt; // all packets smaller than 6 goes as ACK
+
+            m_flag_expect_ack = true;
+            pkt.p_buffer      = (uint8_t *)m_p_tx_packet;
+            pkt.num_of_bytes  = m_tx_packet_length;
+            DEBUG_EVT_SLIP_ACK_TX(0);
+            err_code = ser_phy_hci_slip_tx_pkt_send(&pkt, NULL, NULL); // this will look like ACK for slip
+            ser_phy_nohci_assert(err_code == NRF_SUCCESS);
+        }
+        else
+        {
+            ser_phy_hci_pkt_params_t header;  // this is fake header - just first 4 bytes
+            ser_phy_hci_pkt_params_t crc;     // this is fake header - just last 2 bytes
+            ser_phy_hci_pkt_params_t payload; // this is fake payload - all except for header and crc
+
+            m_flag_expect_ack    = false;
+            header.p_buffer      = (uint8_t *)m_p_tx_packet;
+            header.num_of_bytes  = PKT_HDR_SIZE;
+            crc.p_buffer         = (uint8_t *)m_p_tx_packet + m_tx_packet_length - PKT_CRC_SIZE;
+            crc.num_of_bytes     = PKT_CRC_SIZE;
+            payload.p_buffer     = (uint8_t *)m_p_tx_packet + PKT_HDR_SIZE;
+            payload.num_of_bytes = m_tx_packet_length - PKT_HDR_SIZE - PKT_CRC_SIZE;
+            DEBUG_EVT_SLIP_PACKET_TX(0);
+            err_code = ser_phy_hci_slip_tx_pkt_send(&header, &payload, &crc); // this will look like normal packet for slip
+            ser_phy_nohci_assert(err_code == NRF_SUCCESS);
+        }
+    }
+    else
+    {
+        status = NRF_ERROR_BUSY;
+    }
+
+    return status;
+}
+
+
+/* ser_phy API function */
+uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
+{
+    uint32_t err_code;
+
+    if (m_flag_nohci_init)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (events_handler == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+    err_code = ser_phy_hci_slip_open(hci_slip_event_handler);
+
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    }
+
+    m_ser_phy_callback = events_handler;
+    m_flag_nohci_init  = true;
+    return NRF_SUCCESS;
+}
+
+
+/* ser_phy API function */
+void ser_phy_close(void)
+{
+    m_ser_phy_callback = NULL;
+    ser_phy_hci_slip_close();
+    m_flag_nohci_init = false;
+}
+
+

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_spi_5W_master.c

@@ -0,0 +1,824 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/**@file
+ *
+ * @defgroup ser_phy_spi_5W_phy_driver_master ser_phy_nrf51_spi_5W_master.c
+ * @{
+ * @ingroup ser_phy_spi_5W_phy_driver_master
+ *
+ * @brief SPI_5W_RAW PHY master driver.
+ */
+
+#include <stdio.h>
+#include "app_util.h"
+#include "app_util_platform.h"
+#include "boards.h"
+#include "nrf_error.h"
+#include "nrf_gpio.h"
+#include "nrf_drv_gpiote.h"
+#include "ser_config.h"
+#include "ser_config_5W_app.h"
+#include "ser_phy.h"
+#include "ser_phy_config_app.h"
+#include "spi_5W_master.h"
+#include "ser_phy_debug_app.h"
+#include "app_error.h"
+#define notUSE_PendSV
+
+#ifdef USE_PendSV
+#define SW_IRQn              PendSV_IRQn
+#define SW_IRQ_Handler()     PendSV_Handler()
+#define SET_Pend_SW_IRQ()    SCB->ICSR = SCB->ICSR | SCB_ICSR_PENDSVSET_Msk //NVIC_SetPendingIRQ(PendSV_IRQn) -  PendSV_IRQn is a negative - does not work with CMSIS
+#else
+#define SW_IRQn              SWI3_IRQn
+#define SW_IRQ_Handler()     SWI3_IRQHandler()
+#define SET_Pend_SW_IRQ()    NVIC_SetPendingIRQ(SWI3_IRQn)
+#endif
+
+#define SER_PHY_SPI_5W_MTU_SIZE SER_PHY_SPI_MTU_SIZE
+
+typedef enum
+{
+    SER_PHY_STATE_IDLE = 0,
+    SER_PHY_STATE_TX_HEADER,
+    SER_PHY_STATE_TX_WAIT_FOR_RDY,
+    SER_PHY_STATE_TX_PAYLOAD,
+    SER_PHY_STATE_RX_WAIT_FOR_RDY,
+    SER_PHY_STATE_TX_ZERO_HEADER,
+    SER_PHY_STATE_RX_HEADER,
+    SER_PHY_STATE_MEMORY_REQUEST,
+    SER_PHY_STATE_RX_PAYLOAD,
+    SER_PHY_STATE_DISABLED
+} ser_phy_spi_master_state_t;
+
+typedef enum
+{
+    SER_PHY_EVT_GPIO_RDY = 0,
+    SER_PHY_EVT_GPIO_REQ,
+    SER_PHY_EVT_SPI_TRANSFER_DONE,
+    SER_PHY_EVT_TX_API_CALL,
+    SER_PHY_EVT_RX_API_CALL
+} ser_phy_event_source_t;
+
+#define _static static
+
+_static uint8_t * mp_tx_buffer = NULL;
+_static uint16_t  m_tx_buf_len = 0;
+
+_static uint8_t * mp_rx_buffer = NULL;
+_static uint16_t  m_rx_buf_len = 0;
+_static uint8_t   m_recv_buffer[SER_PHY_SPI_5W_MTU_SIZE];
+_static uint8_t   m_len_buffer[SER_PHY_HEADER_SIZE + 1] = { 0 }; //len is asymmetric for 5W, there is a 1 byte guard when receiving
+
+_static uint16_t m_tx_packet_length             = 0;
+_static uint16_t m_accumulated_tx_packet_length = 0;
+_static uint16_t m_current_tx_packet_length     = 0;
+
+_static uint16_t m_rx_packet_length             = 0;
+_static uint16_t m_accumulated_rx_packet_length = 0;
+_static uint16_t m_current_rx_packet_length     = 0;
+
+_static volatile bool m_pend_req_flag    = 0;
+_static volatile bool m_pend_rdy_flag    = 0;
+_static volatile bool m_pend_xfer_flag   = 0;
+_static volatile bool m_pend_rx_api_flag = 0;
+_static volatile bool m_pend_tx_api_flag = 0;
+
+_static volatile bool m_slave_ready_flag   = false;
+_static volatile bool m_slave_request_flag = false;
+
+
+_static ser_phy_events_handler_t   m_callback_events_handler = NULL;
+_static ser_phy_spi_master_state_t m_spi_master_state        = SER_PHY_STATE_DISABLED;
+
+static void ser_phy_switch_state(ser_phy_event_source_t evt_src);
+
+static void spi_master_raw_assert(bool cond)
+{
+    APP_ERROR_CHECK_BOOL(cond);
+}
+
+void SW_IRQ_Handler()
+{
+    if (m_pend_req_flag)
+    {
+        m_pend_req_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_REQUEST(0);
+        ser_phy_switch_state(SER_PHY_EVT_GPIO_REQ);
+    }
+
+    if (m_pend_rdy_flag)
+    {
+        m_pend_rdy_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_READY(0);
+        ser_phy_switch_state(SER_PHY_EVT_GPIO_RDY);
+    }
+
+    if (m_pend_xfer_flag)
+    {
+        m_pend_xfer_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_XFER_DONE(0);
+        ser_phy_switch_state(SER_PHY_EVT_SPI_TRANSFER_DONE);
+    }
+
+    if (m_pend_rx_api_flag)
+    {
+        m_pend_rx_api_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_API_CALL(0);
+        ser_phy_switch_state(SER_PHY_EVT_RX_API_CALL);
+    }
+
+    if (m_pend_tx_api_flag)
+    {
+        m_pend_tx_api_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_API_CALL(0);
+        ser_phy_switch_state(SER_PHY_EVT_TX_API_CALL);
+    }
+
+}
+
+#ifndef _SPI_5W_
+static void ser_phy_spi_master_ready(nrf_drv_gpiote_pin_t pin,
+                                     nrf_gpiote_polarity_t action)
+{
+    if (nrf_gpio_pin_read(pin) == 0)
+    {
+        m_slave_ready_flag = true;
+        m_pend_rdy_flag    = true;
+    }
+    else
+    {
+        m_slave_ready_flag = false;
+    }
+
+    DEBUG_EVT_SPI_MASTER_RAW_READY_EDGE((uint32_t) !m_slave_ready_flag);
+    SET_Pend_SW_IRQ();
+}
+#endif
+
+static void ser_phy_spi_master_request(nrf_drv_gpiote_pin_t pin,
+                                       nrf_gpiote_polarity_t action)
+{
+    if (nrf_gpio_pin_read(pin) == 0)
+    {
+        m_slave_request_flag = true;
+        m_pend_req_flag      = true;
+    }
+    else
+    {
+        m_slave_request_flag = false;
+    }
+
+    DEBUG_EVT_SPI_MASTER_RAW_REQUEST_EDGE((uint32_t) !m_slave_request_flag);
+    SET_Pend_SW_IRQ();
+}
+
+/* Send event SER_PHY_EVT_TX_PKT_SENT */
+static __INLINE void callback_packet_sent()
+{
+    ser_phy_evt_t event;
+
+    event.evt_type = SER_PHY_EVT_TX_PKT_SENT;
+    m_callback_events_handler(event);
+}
+
+/* Send event SER_PHY_EVT_RX_PKT_DROPPED */
+static __INLINE void callback_packet_dropped()
+{
+    ser_phy_evt_t event;
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_DROPPED;
+    m_callback_events_handler(event);
+}
+
+/* Send event SER_PHY_EVT_RX_PKT_RECEIVED */
+static __INLINE void callback_packet_received()
+{
+    ser_phy_evt_t event;
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_RECEIVED;
+    event.evt_params.rx_pkt_received.p_buffer     = mp_rx_buffer;
+    event.evt_params.rx_pkt_received.num_of_bytes = m_rx_buf_len;
+    m_callback_events_handler(event);
+}
+
+/* Send event SER_PHY_EVT_RX_BUF_REQUEST */
+static __INLINE void callback_mem_request()
+{
+    ser_phy_evt_t event;
+
+    event.evt_type                               = SER_PHY_EVT_RX_BUF_REQUEST;
+    event.evt_params.rx_buf_request.num_of_bytes = m_rx_buf_len;
+    m_callback_events_handler(event);
+}
+
+static __INLINE void copy_buff(uint8_t * const p_dest, uint8_t const * const p_src, uint16_t len)
+{
+    uint16_t index;
+
+    for (index = 0; index < len; index++)
+    {
+        p_dest[index] = p_src[index];
+    }
+    return;
+}
+
+static __INLINE void buffer_release(uint8_t * * const pp_buffer, uint16_t * const p_buf_len)
+{
+    *pp_buffer = NULL;
+    *p_buf_len = 0;
+}
+
+static uint16_t compute_current_packet_length(const uint16_t packet_length,
+                                              const uint16_t accumulated_packet_length)
+{
+    uint16_t current_packet_length = packet_length - accumulated_packet_length;
+
+    if (current_packet_length > SER_PHY_SPI_5W_MTU_SIZE)
+    {
+        current_packet_length = SER_PHY_SPI_5W_MTU_SIZE;
+    }
+
+    return current_packet_length;
+}
+
+static __INLINE uint32_t header_send(const uint16_t length)
+{
+    uint16_t buf_len_size = uint16_encode(length, m_len_buffer);
+
+    return spi_master_send_recv(SER_PHY_SPI_MASTER, m_len_buffer, buf_len_size, NULL, 0);
+}
+
+static __INLINE uint32_t frame_send()
+{
+    uint32_t err_code;
+
+    m_current_tx_packet_length = compute_current_packet_length(m_tx_packet_length,
+                                                               m_accumulated_tx_packet_length);
+    err_code                   =
+        spi_master_send_recv(SER_PHY_SPI_MASTER,
+                             &mp_tx_buffer[m_accumulated_tx_packet_length],
+                             m_current_tx_packet_length,
+                             NULL,
+                             0);
+    m_accumulated_tx_packet_length += m_current_tx_packet_length;
+    return err_code;
+}
+
+static __INLINE uint32_t header_get()
+{
+    return spi_master_send_recv(SER_PHY_SPI_MASTER, NULL, 0, m_len_buffer, SER_PHY_HEADER_SIZE + 1); //add 0 byte guard when receiving
+}
+
+static __INLINE uint32_t frame_get()
+{
+    uint32_t err_code;
+
+    m_current_rx_packet_length = compute_current_packet_length(m_rx_packet_length,
+                                                               m_accumulated_rx_packet_length);
+
+    if (m_current_rx_packet_length < SER_PHY_SPI_5W_MTU_SIZE)
+    {
+        m_current_rx_packet_length++; //take into account guard byte when receiving
+    }
+    err_code = spi_master_send_recv(SER_PHY_SPI_MASTER,
+                                    NULL,
+                                    0,
+                                    m_recv_buffer,
+                                    m_current_rx_packet_length);
+    return err_code;
+}
+
+/**
+ * \brief Master driver main state machine
+ * Executed only in the context of PendSV_Handler()
+ * For UML graph, please refer to SDK documentation
+*/
+
+static void ser_phy_switch_state(ser_phy_event_source_t evt_src)
+{
+    uint32_t    err_code           = NRF_SUCCESS;
+    static bool m_waitForReadyFlag = false; //local scheduling flag to defer RDY events
+
+    switch (m_spi_master_state)
+    {
+
+        case SER_PHY_STATE_IDLE:
+
+            if (evt_src == SER_PHY_EVT_GPIO_REQ)
+            {
+                m_waitForReadyFlag = false;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                    err_code           = header_send(0);
+                }
+                else
+                {
+                    m_spi_master_state = SER_PHY_STATE_RX_WAIT_FOR_RDY;
+                }
+            }
+            else if (evt_src == SER_PHY_EVT_TX_API_CALL)
+            {
+                spi_master_raw_assert(mp_tx_buffer != NULL); //api event with tx_buffer == NULL has no sense
+                m_waitForReadyFlag = false;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_HEADER;
+                    err_code           = header_send(m_tx_buf_len);
+                }
+                else
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_WAIT_FOR_RDY;
+                }
+            }
+            break;
+
+        case SER_PHY_STATE_TX_WAIT_FOR_RDY:
+
+            if (evt_src == SER_PHY_EVT_GPIO_RDY)
+            {
+                m_spi_master_state = SER_PHY_STATE_TX_HEADER;
+                err_code           = header_send(m_tx_buf_len);
+            }
+            break;
+
+        case SER_PHY_STATE_RX_WAIT_FOR_RDY:
+
+            if (evt_src == SER_PHY_EVT_GPIO_RDY)
+            {
+                m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                err_code           = header_send(0);
+
+            }
+            break;
+
+        case SER_PHY_STATE_TX_HEADER:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                m_tx_packet_length             = m_tx_buf_len;
+                m_accumulated_tx_packet_length = 0;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_PAYLOAD;
+                    err_code           = frame_send();
+
+                }
+                else
+                {
+                    m_waitForReadyFlag = true;
+                }
+            }
+            else if ((evt_src == SER_PHY_EVT_GPIO_RDY) && m_waitForReadyFlag)
+            {
+                m_waitForReadyFlag = false;
+                m_spi_master_state = SER_PHY_STATE_TX_PAYLOAD;
+                err_code           = frame_send();
+            }
+
+            break;
+
+        case SER_PHY_STATE_TX_PAYLOAD:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                if (m_accumulated_tx_packet_length < m_tx_packet_length)
+                {
+                    if (m_slave_ready_flag)
+                    {
+                        err_code = frame_send();
+                    }
+                    else
+                    {
+                        m_waitForReadyFlag = true;
+                    }
+                }
+                else
+                {
+                    spi_master_raw_assert(m_accumulated_tx_packet_length == m_tx_packet_length);
+                    //Release TX buffer
+                    buffer_release(&mp_tx_buffer, &m_tx_buf_len);
+                    callback_packet_sent();
+
+                    if ( m_slave_request_flag)
+                    {
+                        if (m_slave_ready_flag)
+                        {
+                            m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                            err_code           = header_send(0);
+                        }
+                        else
+                        {
+                            m_spi_master_state = SER_PHY_STATE_RX_WAIT_FOR_RDY;
+                        }
+                    }
+                    else
+                    {
+                        m_spi_master_state = SER_PHY_STATE_IDLE; //m_Tx_buffer is NULL - have to wait for API event
+                    }
+                }
+            }
+            else if ((evt_src == SER_PHY_EVT_GPIO_RDY) && m_waitForReadyFlag )
+            {
+                m_waitForReadyFlag = false;
+                err_code           = frame_send();
+            }
+
+            break;
+
+        case SER_PHY_STATE_TX_ZERO_HEADER:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_RX_HEADER;
+                    err_code           = header_get();
+                }
+                else
+                {
+                    m_waitForReadyFlag = true;
+                }
+            }
+            else if ( (evt_src == SER_PHY_EVT_GPIO_RDY) && m_waitForReadyFlag)
+            {
+                m_waitForReadyFlag = false;
+                m_spi_master_state = SER_PHY_STATE_RX_HEADER;
+                err_code           = header_get();
+            }
+            break;
+
+        case SER_PHY_STATE_RX_HEADER:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                m_spi_master_state = SER_PHY_STATE_MEMORY_REQUEST;
+                m_rx_buf_len       = uint16_decode(&(m_len_buffer[1])); //skip guard when receiving
+                m_rx_packet_length = m_rx_buf_len;
+                callback_mem_request();
+            }
+            break;
+
+        case SER_PHY_STATE_MEMORY_REQUEST:
+
+            if (evt_src == SER_PHY_EVT_RX_API_CALL)
+            {
+                m_accumulated_rx_packet_length = 0;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_RX_PAYLOAD;
+                    err_code           = frame_get();
+                }
+                else
+                {
+                    m_waitForReadyFlag = true;
+                }
+            }
+            else if ((evt_src == SER_PHY_EVT_GPIO_RDY) && m_waitForReadyFlag)
+            {
+                m_waitForReadyFlag = false;
+                m_spi_master_state = SER_PHY_STATE_RX_PAYLOAD;
+                err_code           = frame_get();
+            }
+            break;
+
+        case SER_PHY_STATE_RX_PAYLOAD:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                if (mp_rx_buffer)
+                {
+                    copy_buff(&(mp_rx_buffer[m_accumulated_rx_packet_length]),
+                              &(m_recv_buffer[1]),
+                              m_current_rx_packet_length - 1); //skip guard byte when receiving
+                }
+                m_accumulated_rx_packet_length += (m_current_rx_packet_length - 1);
+
+                if (m_accumulated_rx_packet_length < m_rx_packet_length)
+                {
+                    if (m_slave_ready_flag)
+                    {
+                        err_code = frame_get();
+                    }
+                    else
+                    {
+                        m_waitForReadyFlag = true;
+                    }
+                }
+                else
+                {
+                    spi_master_raw_assert(m_accumulated_rx_packet_length == m_rx_packet_length);
+
+                    if (mp_rx_buffer == NULL)
+                    {
+                        callback_packet_dropped();
+                    }
+                    else
+                    {
+                        callback_packet_received();
+                    }
+                    //Release RX buffer
+                    buffer_release(&mp_rx_buffer, &m_rx_buf_len);
+
+                    if ((mp_tx_buffer != NULL)) //mp_tx_buffer !=NULL, this means that API_EVT was scheduled
+                    {
+                        if (m_slave_ready_flag )
+                        {
+                            err_code           = header_send(m_tx_buf_len);
+                            m_spi_master_state = SER_PHY_STATE_TX_HEADER;
+                        }
+                        else
+                        {
+                            m_spi_master_state = SER_PHY_STATE_TX_WAIT_FOR_RDY;
+                        }
+                    }
+                    else if (m_slave_request_flag)
+                    {
+                        if (m_slave_ready_flag)
+                        {
+                            m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                            err_code           = header_send(0);
+                        }
+                        else
+                        {
+                            m_spi_master_state = SER_PHY_STATE_RX_WAIT_FOR_RDY;
+                        }
+                    }
+                    else
+                    {
+                        m_spi_master_state = SER_PHY_STATE_IDLE;
+                    }
+                }
+            }
+            else if ( evt_src == SER_PHY_EVT_GPIO_RDY && m_waitForReadyFlag)
+            {
+                m_waitForReadyFlag = false;
+                err_code           = frame_get();
+            }
+
+
+            break;
+
+        default:
+            break;
+    }
+
+
+    if (err_code != NRF_SUCCESS)
+    {
+        (void)err_code;
+    }
+}
+
+/* SPI master event handler */
+static void ser_phy_spi_master_event_handler(spi_master_evt_t spi_master_evt)
+{
+    switch (spi_master_evt.type)
+    {
+        case SPI_MASTER_EVT_TRANSFER_COMPLETED:
+
+            /* Switch state */
+            m_pend_xfer_flag = true;
+            SET_Pend_SW_IRQ();
+
+            break;
+
+        default:
+            break;
+    }
+}
+
+static void ser_phy_init_pendSV(void)
+{
+    NVIC_SetPriority(SW_IRQn, APP_IRQ_PRIORITY_MID);
+    NVIC_EnableIRQ(SW_IRQn);
+}
+
+static void ser_phy_init_gpiote(void)
+{
+    if (!nrf_drv_gpiote_is_init())
+    {
+        (void)nrf_drv_gpiote_init();
+    }
+    NVIC_SetPriority(GPIOTE_IRQn, APP_IRQ_PRIORITY_HIGH);
+
+    nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true);
+    /* Enable pullup to ensure high state while connectivity device is reset */
+    config.pull = NRF_GPIO_PIN_PULLUP;
+    (void)nrf_drv_gpiote_in_init(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST, &config,
+        ser_phy_spi_master_request);
+    nrf_drv_gpiote_in_event_enable(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST,true);
+    m_slave_request_flag = !(nrf_gpio_pin_read(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST));
+
+#ifdef _SPI_5W_
+    m_slave_ready_flag = true;
+#else
+    (void)nrf_drv_gpiote_in_init(SER_PHY_SPI_MASTER_PIN_SLAVE_READY, &config,
+        ser_phy_spi_master_ready);
+    nrf_drv_gpiote_in_event_enable(SER_PHY_SPI_MASTER_PIN_SLAVE_READY,true);
+    m_slave_ready_flag = !(nrf_gpio_pin_read(SER_PHY_SPI_MASTER_PIN_SLAVE_READY));
+#endif
+
+    NVIC_ClearPendingIRQ(SW_IRQn);
+}
+
+static void ser_phy_deinit_gpiote(void)
+{
+    nrf_drv_gpiote_in_uninit(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST);
+#ifndef _SPI_5W_
+    nrf_drv_gpiote_in_uninit(SER_PHY_SPI_MASTER_PIN_SLAVE_READY);
+#endif
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    if (p_buffer == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    if (num_of_bytes == 0)
+    {
+        return NRF_ERROR_INVALID_PARAM;
+    }
+
+    if (mp_tx_buffer != NULL)
+    {
+        return NRF_ERROR_BUSY;
+    }
+
+    //ser_phy_interrupts_disable();
+    CRITICAL_REGION_ENTER();
+    mp_tx_buffer       = (uint8_t *)p_buffer;
+    m_tx_buf_len       = num_of_bytes;
+    m_pend_tx_api_flag = true;
+    SET_Pend_SW_IRQ();
+    //ser_phy_interrupts_enable();
+    CRITICAL_REGION_EXIT();
+
+    return NRF_SUCCESS;
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer)
+{
+    if (m_spi_master_state != SER_PHY_STATE_MEMORY_REQUEST)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    //ser_phy_interrupts_disable();
+    CRITICAL_REGION_ENTER();
+    mp_rx_buffer       = p_buffer;
+    m_pend_rx_api_flag = true;
+    SET_Pend_SW_IRQ();
+    //ser_phy_interrupts_enable();
+    CRITICAL_REGION_EXIT();
+
+    return NRF_SUCCESS;
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
+{
+
+    if (m_spi_master_state != SER_PHY_STATE_DISABLED)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (events_handler == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    uint32_t err_code = NRF_SUCCESS;
+    m_spi_master_state        = SER_PHY_STATE_IDLE;
+    m_callback_events_handler = events_handler;
+    ser_phy_init_gpiote();
+
+    /* Configure SPI Master driver */
+    spi_master_config_t spi_master_config;
+    spi_master_config.SPI_Freq     = SPI_FREQUENCY_FREQUENCY_M1;
+    spi_master_config.SPI_Pin_SCK  = SER_PHY_SPI_MASTER_PIN_SCK;
+    spi_master_config.SPI_Pin_MISO = SER_PHY_SPI_MASTER_PIN_MISO;
+    spi_master_config.SPI_Pin_MOSI = SER_PHY_SPI_MASTER_PIN_MOSI;
+    spi_master_config.SPI_Pin_SS   = SER_PHY_SPI_MASTER_PIN_SLAVE_SELECT;
+    spi_master_config.SPI_ORDER    = SPI_CONFIG_ORDER_LsbFirst;
+    spi_master_config.SPI_CPOL     = SPI_CONFIG_CPOL_ActiveHigh;
+    spi_master_config.SPI_CPHA     = SPI_CONFIG_CPHA_Leading;
+
+    err_code = spi_master_open(SER_PHY_SPI_MASTER, &spi_master_config);
+
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    }
+#ifdef _SPI_5W_
+    spi_5W_master_evt_handler_reg(SER_PHY_SPI_MASTER, ser_phy_spi_master_event_handler);
+#else
+    spi_master_evt_handler_reg(SER_PHY_SPI_MASTER, ser_phy_spi_master_event_handler);
+#endif
+    ser_phy_init_pendSV();
+
+    return err_code;
+}
+
+/* ser_phy API function */
+void ser_phy_close(void)
+{
+    m_spi_master_state = SER_PHY_STATE_DISABLED;
+
+    m_callback_events_handler = NULL;
+
+    buffer_release(&mp_tx_buffer, &m_tx_buf_len);
+    buffer_release(&mp_rx_buffer, &m_rx_buf_len);
+    m_tx_packet_length             = 0;
+    m_accumulated_tx_packet_length = 0;
+    m_current_tx_packet_length     = 0;
+    m_rx_packet_length             = 0;
+    m_accumulated_rx_packet_length = 0;
+    m_current_rx_packet_length     = 0;
+    ser_phy_deinit_gpiote();
+    spi_master_close(SER_PHY_SPI_MASTER);
+}
+
+/* ser_phy API function */
+void ser_phy_interrupts_enable(void)
+{
+    NVIC_EnableIRQ(SW_IRQn);
+}
+
+/* ser_phy API function */
+void ser_phy_interrupts_disable(void)
+{
+    NVIC_DisableIRQ(SW_IRQn);
+}
+
+
+#ifdef SER_PHY_DEBUG_APP_ENABLE
+
+static spi_master_raw_callback_t m_spi_master_raw_evt_callback;
+
+void debug_evt(spi_master_raw_evt_type_t evt, uint32_t data)
+{
+    if (m_spi_master_raw_evt_callback)
+    {
+        spi_master_raw_evt_t e;
+        e.evt  = evt;
+        e.data = data;
+        m_spi_master_raw_evt_callback(e);
+    }
+}
+
+void debug_init(spi_master_raw_callback_t spi_master_raw_evt_callback)
+{
+    m_spi_master_raw_evt_callback = spi_master_raw_evt_callback;
+}
+
+#endif
+/** @} */

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_spi_5W_slave.c

@@ -0,0 +1,646 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/**@file
+ *
+ * @defgroup ser_phy_spi_5W_phy_driver_slave ser_phy_nrf51_spi_5W_slave.c
+ * @{
+ * @ingroup ser_phy_spi_5W_phy_driver_slave
+ *
+ * @brief SPI_5W_RAW PHY slave driver.
+ */
+
+
+#include <stddef.h>
+#include <string.h>
+
+
+#include "boards.h"
+#include "nrf_drv_spis.h"
+#include "ser_phy.h"
+#include "ser_config.h"
+#include "nrf_gpio.h"
+#include "nrf_delay.h"
+#include "nrf_gpiote.h"
+#include "nrf_soc.h"
+#include "app_error.h"
+#include "app_util.h"
+#include "ser_phy_config_conn.h"
+#include "ser_phy_debug_conn.h"
+#include "app_error.h"
+
+#define _static static
+
+#define SER_PHY_SPI_5W_MTU_SIZE SER_PHY_SPI_MTU_SIZE
+
+#define SER_PHY_SPI_DEF_CHARACTER 0xFF //SPI default character. Character clocked out in case of an ignored transaction
+#define SER_PHY_SPI_ORC_CHARACTER 0xFF //SPI over-read character. Character clocked out after an over-read of the transmit buffer
+
+static nrf_drv_spis_t m_spis = NRF_DRV_SPIS_INSTANCE(SER_PHY_SPI_SLAVE_INSTANCE);
+
+#define _SPI_5W_
+
+//SPI raw peripheral device configuration data
+typedef struct
+{
+    int32_t pin_req;       //SPI /REQ pin. -1 for not using
+    int32_t pin_rdy;       //SPI /RDY pin. -1 for not using
+    int32_t ppi_rdy_ch;    //SPI /RDY ppi ready channel
+    int32_t gpiote_rdy_ch; //SPI /RDY pin ready channel
+} spi_slave_raw_trasp_cfg_t;
+
+/**@brief States of the SPI transaction state machine. */
+typedef enum
+{
+    SPI_RAW_STATE_UNKNOWN,
+    SPI_RAW_STATE_SETUP_HEADER,
+    SPI_RAW_STATE_RX_HEADER,
+    SPI_RAW_STATE_MEM_REQUESTED,
+    SPI_RAW_STATE_RX_PAYLOAD,
+    SPI_RAW_STATE_TX_HEADER,
+    SPI_RAW_STATE_TX_PAYLOAD,
+} trans_state_t;
+
+_static spi_slave_raw_trasp_cfg_t m_spi_slave_raw_config;
+
+_static uint16_t m_accumulated_rx_packet_length;
+_static uint16_t m_rx_packet_length;
+_static uint16_t m_current_rx_frame_length;
+
+_static uint16_t m_accumulated_tx_packet_length;
+_static uint16_t m_tx_packet_length;
+_static uint16_t m_current_tx_frame_length;
+
+_static uint8_t m_header_rx_buffer[SER_PHY_HEADER_SIZE + 1]; // + 1 for '0' guard in SPI_5W
+_static uint8_t m_header_tx_buffer[SER_PHY_HEADER_SIZE + 1]; // + 1 for '0' guard in SPI_5W
+
+_static uint8_t m_tx_frame_buffer[SER_PHY_SPI_5W_MTU_SIZE];
+_static uint8_t m_rx_frame_buffer[SER_PHY_SPI_5W_MTU_SIZE];
+_static uint8_t m_zero_buff[SER_PHY_SPI_5W_MTU_SIZE] = {  0  }; //ROM'able declaration - all guard bytes
+
+_static uint8_t * volatile       m_p_rx_buffer = NULL;
+_static const uint8_t * volatile m_p_tx_buffer = NULL;
+
+_static bool m_trash_payload_flag;
+_static bool m_buffer_reqested_flag;
+
+_static trans_state_t            m_trans_state      = SPI_RAW_STATE_UNKNOWN;
+_static ser_phy_events_handler_t m_ser_phy_callback = NULL;
+
+static void spi_slave_raw_assert(bool cond)
+{
+    APP_ERROR_CHECK_BOOL(cond);
+}
+
+static void callback_ser_phy_event(ser_phy_evt_t event)
+{
+    if (m_ser_phy_callback)
+    {
+        m_ser_phy_callback(event);
+    }
+    return;
+}
+
+static void callback_memory_request(uint16_t size)
+{
+    ser_phy_evt_t event;
+
+    event.evt_type                               = SER_PHY_EVT_RX_BUF_REQUEST;
+    event.evt_params.rx_buf_request.num_of_bytes = size;
+    callback_ser_phy_event(event);
+    return;
+
+}
+
+static void callback_packet_received(uint8_t * pBuffer, uint16_t size)
+{
+    ser_phy_evt_t event;
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_RECEIVED;
+    event.evt_params.rx_pkt_received.num_of_bytes = size;
+    event.evt_params.rx_pkt_received.p_buffer     = pBuffer;
+    callback_ser_phy_event(event);
+    return;
+}
+
+static void callback_packet_dropped()
+{
+    ser_phy_evt_t event;
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_DROPPED;
+    callback_ser_phy_event(event);
+    return;
+}
+
+static void callback_packet_transmitted(void)
+{
+    ser_phy_evt_t event;
+
+    event.evt_type = SER_PHY_EVT_TX_PKT_SENT;
+    callback_ser_phy_event(event);
+    return;
+}
+
+static void copy_buff(uint8_t * const p_dest, uint8_t const * const p_src, uint16_t len)
+{
+    uint16_t index;
+
+    for (index = 0; index < len; index++)
+    {
+        p_dest[index] = p_src[index];
+    }
+    return;
+}
+
+/* Function computes current packet length */
+static uint16_t compute_current_frame_length(const uint16_t packet_length,
+                                             const uint16_t accumulated_packet_length)
+{
+    uint16_t current_packet_length = packet_length - accumulated_packet_length;
+
+    if (current_packet_length > SER_PHY_SPI_5W_MTU_SIZE)
+    {
+        current_packet_length = SER_PHY_SPI_5W_MTU_SIZE;
+    }
+
+    return current_packet_length;
+}
+
+static uint32_t header_get()
+{
+    uint32_t err_code;
+
+    err_code = nrf_drv_spis_buffers_set(&m_spis,
+                                        (uint8_t *) m_zero_buff,
+                                        SER_PHY_HEADER_SIZE,
+                                        m_header_rx_buffer,
+                                        SER_PHY_HEADER_SIZE);
+    return err_code;
+}
+
+static uint32_t frame_get()
+{
+    uint32_t err_code;
+
+    m_current_rx_frame_length = compute_current_frame_length(m_rx_packet_length,
+                                                             m_accumulated_rx_packet_length);
+
+    if (!m_trash_payload_flag)
+    {
+        err_code =
+            nrf_drv_spis_buffers_set(&m_spis,
+                                     (uint8_t *) m_zero_buff,
+                                     m_current_rx_frame_length,
+                                     &(m_p_rx_buffer[m_accumulated_rx_packet_length]),
+                                     m_current_rx_frame_length);
+    }
+    else
+    {
+        err_code = nrf_drv_spis_buffers_set(&m_spis,
+                                            (uint8_t *) m_zero_buff,
+                                            m_current_rx_frame_length,
+                                            m_rx_frame_buffer,
+                                            m_current_rx_frame_length);
+    }
+    return err_code;
+}
+
+static uint32_t header_send(uint16_t len)
+{
+    uint32_t err_code;
+
+    m_header_tx_buffer[0] = (uint8_t) 0; //this is guard byte
+    (void)uint16_encode(len, &(m_header_tx_buffer[1]));
+    err_code = nrf_drv_spis_buffers_set(&m_spis,
+                                        m_header_tx_buffer,
+                                        SER_PHY_HEADER_SIZE + 1,
+                                        m_header_rx_buffer,
+                                        SER_PHY_HEADER_SIZE + 1);
+    return err_code;
+}
+
+static uint32_t frame_send()
+{
+    uint32_t err_code;
+
+    m_current_tx_frame_length = compute_current_frame_length(m_tx_packet_length,
+                                                             m_accumulated_tx_packet_length);
+
+    if (m_current_tx_frame_length == SER_PHY_SPI_5W_MTU_SIZE)
+    {
+        m_current_tx_frame_length -= 1; //extra space for guard byte must be taken into account for MTU
+    }
+    m_tx_frame_buffer[0] = 0; //guard byte
+    copy_buff(&(m_tx_frame_buffer[1]),
+              &(m_p_tx_buffer[m_accumulated_tx_packet_length]),
+              m_current_tx_frame_length);
+    err_code = nrf_drv_spis_buffers_set(&m_spis,
+                                        m_tx_frame_buffer,
+                                        m_current_tx_frame_length + 1,
+                                        m_rx_frame_buffer,
+                                        m_current_tx_frame_length + 1);
+
+    return err_code;
+}
+
+static void set_ready_line(void)
+{
+#ifndef _SPI_5W_
+    //toggle - this should go high - but toggle is unsafe
+    uint32_t rdy_task = nrf_drv_gpiote_out_task_addr_get(m_spi_slave_raw_config.gpiote_rdy_ch);
+    *(uint32_t *)rdy_task = 1;
+#endif
+    return;
+}
+
+static void set_request_line(void)
+{
+    //active low logic - set is 0
+    nrf_gpio_pin_clear(m_spi_slave_raw_config.pin_req);
+    DEBUG_EVT_SPI_SLAVE_RAW_REQ_SET(0);
+    return;
+}
+
+static void clear_request_line(void)
+{
+    //active low logic - clear is 1
+    nrf_gpio_pin_set(m_spi_slave_raw_config.pin_req);
+    DEBUG_EVT_SPI_SLAVE_RAW_REQ_CLEARED(0);
+    return;
+}
+
+/**
+ * \brief Slave driver main state machine
+ * For UML graph, please refer to SDK documentation
+*/
+static void spi_slave_event_handle(nrf_drv_spis_event_t event)
+{
+    static uint32_t err_code = NRF_SUCCESS;
+    static uint16_t packetLength;
+
+    switch (m_trans_state)
+    {
+        case SPI_RAW_STATE_SETUP_HEADER:
+            m_trans_state = SPI_RAW_STATE_RX_HEADER;
+            err_code      = header_get();
+            break;
+
+        case SPI_RAW_STATE_RX_HEADER:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_RX_XFER_DONE(event.rx_amount);
+                spi_slave_raw_assert(event.rx_amount == SER_PHY_HEADER_SIZE);
+                packetLength = uint16_decode(m_header_rx_buffer);
+
+                if (packetLength != 0 )
+                {
+                    m_trans_state          = SPI_RAW_STATE_MEM_REQUESTED;
+                    m_buffer_reqested_flag = true;
+                    m_rx_packet_length     = packetLength;
+                    callback_memory_request(packetLength);
+                }
+                else
+                {
+                    if (m_p_tx_buffer)
+                    {
+                        clear_request_line();
+                        m_trans_state = SPI_RAW_STATE_TX_HEADER;
+                        err_code      = header_send(m_tx_packet_length);
+                    }
+                    else
+                    {
+                        //there is nothing to send - zero response facilitates pooling - but perhaps, it should be assert
+                        err_code = header_send(0);
+                    }
+                }
+            }
+
+            break;
+
+        case SPI_RAW_STATE_MEM_REQUESTED:
+
+            if (event.evt_type == NRF_DRV_SPIS_EVT_TYPE_MAX) //This is API dummy event
+            {
+                m_buffer_reqested_flag         = false;
+                m_trans_state                  = SPI_RAW_STATE_RX_PAYLOAD;
+                m_accumulated_rx_packet_length = 0;
+                err_code                       = frame_get();
+            }
+            break;
+
+
+        case SPI_RAW_STATE_RX_PAYLOAD:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_RX_XFER_DONE(event.rx_amount);
+                spi_slave_raw_assert(event.rx_amount == m_current_rx_frame_length);
+                m_accumulated_rx_packet_length += m_current_rx_frame_length;
+
+                if (m_accumulated_rx_packet_length < m_rx_packet_length )
+                {
+                    err_code = frame_get();
+                }
+                else
+                {
+                    spi_slave_raw_assert(m_accumulated_rx_packet_length == m_rx_packet_length);
+                    m_trans_state = SPI_RAW_STATE_RX_HEADER;
+                    err_code      = header_get();
+
+                    if (!m_trash_payload_flag)
+                    {
+                        callback_packet_received(m_p_rx_buffer, m_accumulated_rx_packet_length);
+                    }
+                    else
+                    {
+                        callback_packet_dropped();
+                    }
+                }
+            }
+            break;
+
+        case SPI_RAW_STATE_TX_HEADER:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_TX_XFER_DONE(event.tx_amount);
+                spi_slave_raw_assert(event.tx_amount == SER_PHY_HEADER_SIZE + 1);
+                m_trans_state                  = SPI_RAW_STATE_TX_PAYLOAD;
+                m_accumulated_tx_packet_length = 0;
+                err_code                       = frame_send();
+            }
+
+            break;
+
+        case SPI_RAW_STATE_TX_PAYLOAD:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_TX_XFER_DONE(event.tx_amount);
+                spi_slave_raw_assert(event.tx_amount == m_current_tx_frame_length + 1);
+                m_accumulated_tx_packet_length += m_current_tx_frame_length;
+
+                if ( m_accumulated_tx_packet_length < m_tx_packet_length )
+                {
+                    err_code = frame_send();
+                }
+                else
+                {
+                    spi_slave_raw_assert(m_accumulated_tx_packet_length == m_tx_packet_length);
+                    //clear pointer before callback
+                    m_p_tx_buffer = NULL;
+                    callback_packet_transmitted();
+                    //spi slave TX transfer is possible only when RX is ready, so return to waiting for a header
+                    m_trans_state = SPI_RAW_STATE_RX_HEADER;
+                    err_code      = header_get();
+                }
+            }
+            break;
+
+        default:
+            err_code = NRF_ERROR_INVALID_STATE;
+            break;
+    }
+    APP_ERROR_CHECK(err_code);
+}
+
+#ifndef _SPI_5W_
+static void spi_slave_gpiote_init(void)
+{
+    if (!nrf_drv_gpiote_is_init())
+    {
+        (void)nrf_drv_gpiote_init();
+    }
+    nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(true);
+    (void)nrf_drv_gpiote_out_init(m_spi_slave_raw_config.gpiote_rdy_ch, &config);
+    return;
+}
+
+static void spi_slave_ppi_init(void)
+{
+    uint32_t rdy_task = nrf_drv_gpiote_out_task_addr_get(m_spi_slave_raw_config.gpiote_rdy_ch);
+    //Configure PPI channel  to clear /RDY line
+    NRF_PPI->CH[m_spi_slave_raw_config.ppi_rdy_ch].EEP = (uint32_t)(&NRF_SPIS1->EVENTS_END);
+    NRF_PPI->CH[m_spi_slave_raw_config.ppi_rdy_ch].TEP = rdy_task;
+
+    //this works only for channels 0..15 - but soft device is using 8-15 anyway
+    NRF_PPI->CHEN |= (1 << m_spi_slave_raw_config.ppi_rdy_ch);
+    return;
+}
+#endif
+
+static void spi_slave_gpio_init(void)
+{
+    nrf_gpio_pin_set(m_spi_slave_raw_config.pin_req);
+    nrf_gpio_cfg_output(m_spi_slave_raw_config.pin_req);
+#ifndef _SPI_5W_
+    nrf_gpio_pin_set(m_spi_slave_raw_config.pin_rdy);
+    nrf_gpio_cfg_output(m_spi_slave_raw_config.pin_rdy);
+#endif
+    return;
+}
+
+/* ser_phy API function */
+void ser_phy_interrupts_enable(void)
+{
+    NVIC_EnableIRQ(m_spis.irq);
+}
+
+/* ser_phy API function */
+void ser_phy_interrupts_disable(void)
+{
+    NVIC_DisableIRQ(m_spis.irq);
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer)
+{
+    uint32_t             status = NRF_SUCCESS;
+    nrf_drv_spis_event_t event;
+
+    ser_phy_interrupts_disable();
+
+    if (m_buffer_reqested_flag && (m_trans_state == SPI_RAW_STATE_MEM_REQUESTED))
+    {
+        m_p_rx_buffer = p_buffer;
+
+        if (m_p_rx_buffer)
+        {
+            m_trash_payload_flag = false;
+        }
+        else
+        {
+            m_trash_payload_flag = true;
+        }
+
+        event.evt_type  = NRF_DRV_SPIS_EVT_TYPE_MAX; //force transition with dummy event
+        event.rx_amount = 0;
+        event.tx_amount = 0;
+        spi_slave_event_handle(event);
+    }
+    else
+    {
+        status = NRF_ERROR_BUSY;
+    }
+    ser_phy_interrupts_enable();
+
+    return status;
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    uint32_t status = NRF_SUCCESS;
+
+    if ( p_buffer == NULL || num_of_bytes == 0)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    ser_phy_interrupts_disable();
+
+    if ( m_p_tx_buffer == NULL)
+    {
+        m_tx_packet_length = num_of_bytes;
+        m_p_tx_buffer      = p_buffer;
+        set_request_line();
+    }
+    else
+    {
+        status = NRF_ERROR_BUSY;
+    }
+    ser_phy_interrupts_enable();
+
+    return status;
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
+{
+    uint32_t              err_code;
+    nrf_drv_spis_config_t spi_slave_config;
+    nrf_drv_spis_event_t  event;
+
+    if (m_trans_state != SPI_RAW_STATE_UNKNOWN)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (events_handler == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    //one ppi channel and one gpiote channel are used to drive RDY line
+    m_spi_slave_raw_config.pin_req       = SER_PHY_SPI_SLAVE_REQ_PIN;
+    m_spi_slave_raw_config.pin_rdy       = SER_PHY_SPI_SLAVE_RDY_PIN;
+    m_spi_slave_raw_config.ppi_rdy_ch    = SER_PHY_SPI_PPI_RDY_CH;
+    m_spi_slave_raw_config.gpiote_rdy_ch = SER_PHY_SPI_GPIOTE_RDY_CH;
+
+    spi_slave_gpio_init();
+#ifndef _SPI_5W_
+    spi_slave_gpiote_init();
+    spi_slave_ppi_init();
+#endif
+
+    spi_slave_config.miso_pin         = SER_CON_SPIS_MISO_PIN;
+    spi_slave_config.mosi_pin         = SER_CON_SPIS_MOSI_PIN;
+    spi_slave_config.sck_pin          = SER_CON_SPIS_SCK_PIN;
+    spi_slave_config.csn_pin          = SER_CON_SPIS_CSN_PIN;
+    spi_slave_config.mode             = NRF_DRV_SPIS_MODE_0;
+    spi_slave_config.bit_order        = NRF_DRV_SPIS_BIT_ORDER_LSB_FIRST;
+    spi_slave_config.def              = SER_PHY_SPI_DEF_CHARACTER;
+    spi_slave_config.orc              = SER_PHY_SPI_ORC_CHARACTER;
+    spi_slave_config.csn_pullup       = NRF_GPIO_PIN_PULLUP;
+    spi_slave_config.irq_priority     = APP_IRQ_PRIORITY_LOWEST;
+
+    //keep /CS high when init
+    nrf_gpio_cfg_input(spi_slave_config.csn_pin, NRF_GPIO_PIN_PULLUP);
+
+    err_code = nrf_drv_spis_init(&m_spis, &spi_slave_config, spi_slave_event_handle);
+    APP_ERROR_CHECK(err_code);
+
+    if (err_code == NRF_SUCCESS)
+    {
+        m_ser_phy_callback = events_handler;
+
+        m_trans_state   = SPI_RAW_STATE_SETUP_HEADER;
+        event.evt_type  = NRF_DRV_SPIS_EVT_TYPE_MAX; //force transition for dummy event
+        event.rx_amount = 0;
+        event.tx_amount = 0;
+        spi_slave_event_handle(event);
+
+    }
+
+    return err_code;
+}
+
+/* ser_phy API function */
+void ser_phy_close(void)
+{
+    nrf_drv_spis_uninit(&m_spis);
+    m_ser_phy_callback = NULL;
+    m_trans_state      = SPI_RAW_STATE_UNKNOWN;
+}

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_spi_master.c

@@ -0,0 +1,802 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/**@file
+ *
+ * @defgroup ser_phy_spi_phy_driver_master ser_phy_nrf51_spi_master.c
+ * @{
+ * @ingroup ser_phy_spi_phy_driver_master
+ *
+ * @brief SPI_RAW PHY master driver.
+ */
+
+#include <stdio.h>
+#include "nrf_drv_gpiote.h"
+#include "nrf_drv_spi.h"
+#include "ser_phy.h"
+#include "ser_config.h"
+#include "app_util.h"
+#include "app_util_platform.h"
+#include "app_error.h"
+#include "nrf_error.h"
+#include "nrf_gpio.h"
+#include "nrf_gpiote.h"
+#include "boards.h"
+#include "app_error.h"
+#include "ser_phy_config_app.h"
+#include "ser_phy_debug_app.h"
+
+#define notUSE_PendSV
+
+#ifdef USE_PendSV
+
+#define SW_IRQn              PendSV_IRQn
+#define SW_IRQ_Handler()     PendSV_Handler()
+#define SET_Pend_SW_IRQ()    SCB->ICSR = SCB->ICSR | SCB_ICSR_PENDSVSET_Msk //NVIC_SetPendingIRQ(PendSV_IRQn) -  PendSV_IRQn is a negative - does not work with CMSIS
+
+#else
+
+#define SW_IRQn              SWI3_IRQn
+#define SW_IRQ_Handler()     SWI3_IRQHandler()
+#define SET_Pend_SW_IRQ()    NVIC_SetPendingIRQ(SWI3_IRQn)
+#endif /* USE_PendSV */
+
+typedef enum
+{
+    SER_PHY_STATE_IDLE = 0,
+    SER_PHY_STATE_TX_HEADER,
+    SER_PHY_STATE_TX_WAIT_FOR_RDY,
+    SER_PHY_STATE_TX_PAYLOAD,
+    SER_PHY_STATE_RX_WAIT_FOR_RDY,
+    SER_PHY_STATE_TX_ZERO_HEADER,
+    SER_PHY_STATE_RX_HEADER,
+    SER_PHY_STATE_MEMORY_REQUEST,
+    SER_PHY_STATE_RX_PAYLOAD,
+    SER_PHY_STATE_DISABLED
+} ser_phy_spi_master_state_t;
+
+typedef enum
+{
+    SER_PHY_EVT_GPIO_RDY = 0,
+    SER_PHY_EVT_GPIO_REQ,
+    SER_PHY_EVT_SPI_TRANSFER_DONE,
+    SER_PHY_EVT_TX_API_CALL,
+    SER_PHY_EVT_RX_API_CALL
+} ser_phy_event_source_t;
+
+#define _static static
+
+_static uint8_t * mp_tx_buffer = NULL;
+_static uint16_t  m_tx_buf_len = 0;
+
+_static uint8_t * mp_rx_buffer = NULL;
+_static uint16_t  m_rx_buf_len = 0;
+_static uint8_t   m_frame_buffer[SER_PHY_SPI_MTU_SIZE];
+_static uint8_t   m_header_buffer[SER_PHY_HEADER_SIZE] = { 0 };
+
+_static uint16_t m_tx_packet_length             = 0;
+_static uint16_t m_accumulated_tx_packet_length = 0;
+_static uint16_t m_current_tx_packet_length     = 0;
+
+_static uint16_t m_rx_packet_length             = 0;
+_static uint16_t m_accumulated_rx_packet_length = 0;
+_static uint16_t m_current_rx_packet_length     = 0;
+
+_static volatile bool m_pend_req_flag    = 0;
+_static volatile bool m_pend_rdy_flag    = 0;
+_static volatile bool m_pend_xfer_flag   = 0;
+_static volatile bool m_pend_rx_api_flag = 0;
+_static volatile bool m_pend_tx_api_flag = 0;
+
+_static volatile bool m_slave_ready_flag   = false;
+_static volatile bool m_slave_request_flag = false;
+
+_static ser_phy_events_handler_t   m_callback_events_handler = NULL;
+_static ser_phy_spi_master_state_t m_spi_master_state        = SER_PHY_STATE_DISABLED;
+
+_static const nrf_drv_spi_t m_spi_master = SER_PHY_SPI_MASTER_INSTANCE;
+
+static void ser_phy_switch_state(ser_phy_event_source_t evt_src);
+
+static void spi_master_raw_assert(bool cond)
+{
+    APP_ERROR_CHECK_BOOL(cond);
+}
+
+void SW_IRQ_Handler()
+{
+    if (m_pend_req_flag)
+    {
+        m_pend_req_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_REQUEST(0);
+        ser_phy_switch_state(SER_PHY_EVT_GPIO_REQ);
+    }
+
+    if (m_pend_rdy_flag)
+    {
+        m_pend_rdy_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_READY(0);
+        ser_phy_switch_state(SER_PHY_EVT_GPIO_RDY);
+    }
+
+    if (m_pend_xfer_flag)
+    {
+        m_pend_xfer_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_XFER_DONE(0);
+        ser_phy_switch_state(SER_PHY_EVT_SPI_TRANSFER_DONE);
+    }
+
+    if (m_pend_rx_api_flag)
+    {
+        m_pend_rx_api_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_API_CALL(0);
+        ser_phy_switch_state(SER_PHY_EVT_RX_API_CALL);
+    }
+
+    if (m_pend_tx_api_flag)
+    {
+        m_pend_tx_api_flag = false;
+        DEBUG_EVT_SPI_MASTER_RAW_API_CALL(0);
+        ser_phy_switch_state(SER_PHY_EVT_TX_API_CALL);
+    }
+}
+
+static void ser_phy_spi_master_ready(nrf_drv_gpiote_pin_t pin,
+                                     nrf_gpiote_polarity_t action)
+{
+    if (nrf_gpio_pin_read(pin) == 0)
+    {
+        m_slave_ready_flag = true;
+        m_pend_rdy_flag    = true;
+    }
+    else
+    {
+        m_slave_ready_flag = false;
+    }
+
+    DEBUG_EVT_SPI_MASTER_RAW_READY_EDGE((uint32_t) !m_slave_ready_flag);
+    SET_Pend_SW_IRQ();
+}
+
+static void ser_phy_spi_master_request(nrf_drv_gpiote_pin_t pin,
+                                       nrf_gpiote_polarity_t action)
+{
+    if (nrf_gpio_pin_read(pin) == 0)
+    {
+        m_slave_request_flag = true;
+        m_pend_req_flag      = true;
+    }
+    else
+    {
+        m_slave_request_flag = false;
+    }
+
+    DEBUG_EVT_SPI_MASTER_RAW_REQUEST_EDGE((uint32_t) !m_slave_request_flag);
+    SET_Pend_SW_IRQ();
+}
+
+/* Send event SER_PHY_EVT_TX_PKT_SENT */
+static __INLINE void callback_packet_sent()
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_MASTER_PHY_TX_PKT_SENT(0);
+
+    event.evt_type = SER_PHY_EVT_TX_PKT_SENT;
+    m_callback_events_handler(event);
+}
+
+/* Send event SER_PHY_EVT_RX_PKT_DROPPED */
+static __INLINE void callback_packet_dropped()
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_MASTER_PHY_RX_PKT_DROPPED(0);
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_DROPPED;
+    m_callback_events_handler(event);
+}
+
+/* Send event SER_PHY_EVT_RX_PKT_RECEIVED */
+static __INLINE void callback_packet_received()
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_MASTER_PHY_RX_PKT_RECEIVED(0);
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_RECEIVED;
+    event.evt_params.rx_pkt_received.p_buffer     = mp_rx_buffer;
+    event.evt_params.rx_pkt_received.num_of_bytes = m_rx_buf_len;
+    m_callback_events_handler(event);
+}
+
+/* Send event SER_PHY_EVT_RX_BUF_REQUEST */
+static __INLINE void callback_mem_request()
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_MASTER_PHY_BUF_REQUEST(0);
+
+    event.evt_type                               = SER_PHY_EVT_RX_BUF_REQUEST;
+    event.evt_params.rx_buf_request.num_of_bytes = m_rx_buf_len;
+    m_callback_events_handler(event);
+}
+
+/* Release buffer */
+static __INLINE void buffer_release(uint8_t * * const pp_buffer,
+                                    uint16_t * const  p_buf_len)
+{
+    *pp_buffer = NULL;
+    *p_buf_len = 0;
+}
+
+/* Function computes current packet length */
+static uint16_t compute_current_packet_length(const uint16_t packet_length,
+                                              const uint16_t accumulated_packet_length)
+{
+    uint16_t current_packet_length = packet_length - accumulated_packet_length;
+
+    if (current_packet_length > SER_PHY_SPI_MTU_SIZE)
+    {
+        current_packet_length = SER_PHY_SPI_MTU_SIZE;
+    }
+
+    return current_packet_length;
+}
+
+static __INLINE uint32_t header_send(const uint16_t length)
+{
+    uint8_t buf_len_size = uint16_encode(length, m_header_buffer);
+
+    return nrf_drv_spi_transfer(&m_spi_master, m_header_buffer, buf_len_size, NULL, 0);
+}
+
+
+static __INLINE uint32_t frame_send()
+{
+    uint32_t err_code;
+
+    m_current_tx_packet_length = compute_current_packet_length(m_tx_packet_length,
+                                                               m_accumulated_tx_packet_length);
+    err_code                   =
+        nrf_drv_spi_transfer(&m_spi_master,
+                             &mp_tx_buffer[m_accumulated_tx_packet_length],
+                             m_current_tx_packet_length,
+                             NULL,
+                             0);
+    m_accumulated_tx_packet_length += m_current_tx_packet_length;
+    return err_code;
+}
+
+static __INLINE uint32_t header_get()
+{
+    return nrf_drv_spi_transfer(&m_spi_master, NULL, 0, m_header_buffer, SER_PHY_HEADER_SIZE);
+}
+
+static __INLINE uint32_t frame_get()
+{
+    uint32_t err_code;
+
+    m_current_rx_packet_length = compute_current_packet_length(m_rx_packet_length,
+                                                               m_accumulated_rx_packet_length);
+
+    if (mp_rx_buffer)
+    {
+        err_code = nrf_drv_spi_transfer(&m_spi_master,
+                                        NULL,
+                                        0,
+                                        &(mp_rx_buffer[m_accumulated_rx_packet_length]),
+                                        m_current_rx_packet_length);
+    }
+    else
+    {
+        err_code = nrf_drv_spi_transfer(&m_spi_master,
+                                        NULL,
+                                        0,
+                                        m_frame_buffer,
+                                        m_current_rx_packet_length);
+    }
+    return err_code;
+}
+
+
+/**
+ * \brief Master driver main state machine
+ * Executed only in the context of PendSV_Handler()
+ * For UML graph, please refer to SDK documentation
+*/
+static void ser_phy_switch_state(ser_phy_event_source_t evt_src)
+{
+    uint32_t    err_code           = NRF_SUCCESS;
+    static bool m_wait_for_ready_flag = false; //local scheduling flag to defer RDY events
+
+    switch (m_spi_master_state)
+    {
+
+        case SER_PHY_STATE_IDLE:
+
+            if (evt_src == SER_PHY_EVT_GPIO_REQ)
+            {
+                m_wait_for_ready_flag = false;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                    err_code           = header_send(0);
+                }
+                else
+                {
+                    m_spi_master_state = SER_PHY_STATE_RX_WAIT_FOR_RDY;
+                }
+            }
+            else if (evt_src == SER_PHY_EVT_TX_API_CALL)
+            {
+                spi_master_raw_assert(mp_tx_buffer != NULL); //api event with tx_buffer == NULL has no sense
+                m_wait_for_ready_flag = false;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_HEADER;
+                    err_code           = header_send(m_tx_buf_len);
+                }
+                else
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_WAIT_FOR_RDY;
+                }
+            }
+            break;
+
+        case SER_PHY_STATE_TX_WAIT_FOR_RDY:
+
+            if (evt_src == SER_PHY_EVT_GPIO_RDY)
+            {
+                m_spi_master_state = SER_PHY_STATE_TX_HEADER;
+                err_code           = header_send(m_tx_buf_len);
+            }
+            break;
+
+        case SER_PHY_STATE_RX_WAIT_FOR_RDY:
+
+            if (evt_src == SER_PHY_EVT_GPIO_RDY)
+            {
+                m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                err_code           = header_send(0);
+
+            }
+            break;
+
+        case SER_PHY_STATE_TX_HEADER:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                m_tx_packet_length             = m_tx_buf_len;
+                m_accumulated_tx_packet_length = 0;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_TX_PAYLOAD;
+                    err_code           = frame_send();
+
+                }
+                else
+                {
+                    m_wait_for_ready_flag = true;
+                }
+            }
+            else if ((evt_src == SER_PHY_EVT_GPIO_RDY) && m_wait_for_ready_flag)
+            {
+                m_wait_for_ready_flag = false;
+                m_spi_master_state = SER_PHY_STATE_TX_PAYLOAD;
+                err_code           = frame_send();
+            }
+
+            break;
+
+        case SER_PHY_STATE_TX_PAYLOAD:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                if (m_accumulated_tx_packet_length < m_tx_packet_length)
+                {
+                    if (m_slave_ready_flag)
+                    {
+                        err_code = frame_send();
+                    }
+                    else
+                    {
+                        m_wait_for_ready_flag = true;
+                    }
+                }
+                else
+                {
+                    spi_master_raw_assert(m_accumulated_tx_packet_length == m_tx_packet_length);
+                    buffer_release(&mp_tx_buffer, &m_tx_buf_len);
+                    callback_packet_sent();
+                    if ( m_slave_request_flag)
+                    {
+                        if (m_slave_ready_flag)
+                        {
+                            m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                            err_code           = header_send(0);
+                        }
+                        else
+                        {
+                            m_spi_master_state = SER_PHY_STATE_RX_WAIT_FOR_RDY;
+                        }
+                    }
+                    else
+                    {
+                        m_spi_master_state = SER_PHY_STATE_IDLE; //m_Tx_buffer is NULL - have to wait for API event
+                    }
+                }
+            }
+            else if ((evt_src == SER_PHY_EVT_GPIO_RDY) && m_wait_for_ready_flag )
+            {
+                m_wait_for_ready_flag = false;
+                err_code           = frame_send();
+            }
+
+            break;
+
+        case SER_PHY_STATE_TX_ZERO_HEADER:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_RX_HEADER;
+                    err_code           = header_get();
+                }
+                else
+                {
+                    m_wait_for_ready_flag = true;
+                }
+            }
+            else if ( (evt_src == SER_PHY_EVT_GPIO_RDY) && m_wait_for_ready_flag)
+            {
+                m_wait_for_ready_flag = false;
+                m_spi_master_state = SER_PHY_STATE_RX_HEADER;
+                err_code           = header_get();
+            }
+            break;
+
+        case SER_PHY_STATE_RX_HEADER:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                m_spi_master_state = SER_PHY_STATE_MEMORY_REQUEST;
+                m_rx_buf_len       = uint16_decode(m_header_buffer);
+                m_rx_packet_length = m_rx_buf_len;
+                callback_mem_request();
+
+            }
+            break;
+
+        case SER_PHY_STATE_MEMORY_REQUEST:
+
+            if (evt_src == SER_PHY_EVT_RX_API_CALL)
+            {
+                m_accumulated_rx_packet_length = 0;
+
+                if (m_slave_ready_flag)
+                {
+                    m_spi_master_state = SER_PHY_STATE_RX_PAYLOAD;
+                    err_code           = frame_get();
+                }
+                else
+                {
+                    m_wait_for_ready_flag = true;
+                }
+            }
+            else if ((evt_src == SER_PHY_EVT_GPIO_RDY) && m_wait_for_ready_flag)
+            {
+                m_wait_for_ready_flag = false;
+                m_spi_master_state = SER_PHY_STATE_RX_PAYLOAD;
+                err_code           = frame_get();
+            }
+            break;
+
+        case SER_PHY_STATE_RX_PAYLOAD:
+
+            if (evt_src == SER_PHY_EVT_SPI_TRANSFER_DONE)
+            {
+                m_accumulated_rx_packet_length += m_current_rx_packet_length;
+
+                if (m_accumulated_rx_packet_length < m_rx_packet_length)
+                {
+                    if (m_slave_ready_flag)
+                    {
+                        err_code = frame_get();
+                    }
+                    else
+                    {
+                        m_wait_for_ready_flag = true;
+                    }
+                }
+                else
+                {
+                    spi_master_raw_assert(m_accumulated_rx_packet_length == m_rx_packet_length);
+
+                    if (mp_rx_buffer == NULL)
+                    {
+                        callback_packet_dropped();
+                    }
+                    else
+                    {
+                        callback_packet_received();
+                    }
+                    buffer_release(&mp_rx_buffer, &m_rx_buf_len);
+                    if (mp_tx_buffer != NULL) //mp_tx_buffer !=NULL, this means that API_EVT was scheduled
+                    {
+                        if (m_slave_ready_flag )
+                        {
+                            err_code           = header_send(m_tx_buf_len);
+                            m_spi_master_state = SER_PHY_STATE_TX_HEADER;
+                        }
+                        else
+                        {
+                            m_spi_master_state = SER_PHY_STATE_TX_WAIT_FOR_RDY;
+                        }
+                    }
+                    else if (m_slave_request_flag)
+                    {
+                        if (m_slave_ready_flag)
+                        {
+                            m_spi_master_state = SER_PHY_STATE_TX_ZERO_HEADER;
+                            err_code           = header_send(0);
+                        }
+                        else
+                        {
+                            m_spi_master_state = SER_PHY_STATE_RX_WAIT_FOR_RDY;
+                        }
+                    }
+                    else
+                    {
+                        m_spi_master_state = SER_PHY_STATE_IDLE;
+
+                    }
+                }
+
+            }
+            else if ( evt_src == SER_PHY_EVT_GPIO_RDY && m_wait_for_ready_flag)
+            {
+                m_wait_for_ready_flag = false;
+                err_code           = frame_get();
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    if (err_code != NRF_SUCCESS)
+    {
+        (void)err_code;
+    }
+}
+
+static void ser_phy_spi_master_event_handler(nrf_drv_spi_evt_t const * p_event)
+{
+    switch (p_event->type)
+    {
+        case NRF_DRV_SPI_EVENT_DONE:
+
+            /* Switch state */
+            m_pend_xfer_flag = true;
+            SET_Pend_SW_IRQ();
+
+            break;
+
+        default:
+            break;
+    }
+}
+
+static void ser_phy_init_PendSV(void)
+{
+    NVIC_SetPriority(SW_IRQn, APP_IRQ_PRIORITY_MID);
+    NVIC_EnableIRQ(SW_IRQn);
+}
+
+static ret_code_t ser_phy_init_gpiote(void)
+{
+    if (!nrf_drv_gpiote_is_init())
+    {
+        (void)nrf_drv_gpiote_init();
+    }
+    NVIC_SetPriority(GPIOTE_IRQn, APP_IRQ_PRIORITY_HIGH);
+
+    nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true);
+    /* Enable pullup to ensure high state while connectivity device is reset */
+    config.pull = NRF_GPIO_PIN_PULLUP;
+    ret_code_t err_code = nrf_drv_gpiote_in_init(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST,
+        &config, ser_phy_spi_master_request);
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    }
+    nrf_drv_gpiote_in_event_enable(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST,true);
+
+    err_code = nrf_drv_gpiote_in_init(SER_PHY_SPI_MASTER_PIN_SLAVE_READY,
+        &config, ser_phy_spi_master_ready);
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    }
+    nrf_drv_gpiote_in_event_enable(SER_PHY_SPI_MASTER_PIN_SLAVE_READY,true);
+
+    m_slave_request_flag = !(nrf_gpio_pin_read(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST));
+    m_slave_ready_flag   = !(nrf_gpio_pin_read(SER_PHY_SPI_MASTER_PIN_SLAVE_READY));
+
+    NVIC_ClearPendingIRQ(SW_IRQn);
+
+    return NRF_SUCCESS;
+}
+
+static void ser_phy_deinit_gpiote(void)
+{
+    nrf_drv_gpiote_in_uninit(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST);
+    nrf_drv_gpiote_in_uninit(SER_PHY_SPI_MASTER_PIN_SLAVE_READY);
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    if (p_buffer == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    if (num_of_bytes == 0)
+    {
+        return NRF_ERROR_INVALID_PARAM;
+    }
+
+    if (mp_tx_buffer != NULL)
+    {
+        return NRF_ERROR_BUSY;
+    }
+
+    //ser_phy_interrupts_disable();
+    CRITICAL_REGION_ENTER();
+    mp_tx_buffer       = (uint8_t *)p_buffer;
+    m_tx_buf_len       = num_of_bytes;
+    m_pend_tx_api_flag = true;
+    SET_Pend_SW_IRQ();
+    //ser_phy_interrupts_enable();
+    CRITICAL_REGION_EXIT();
+
+    return NRF_SUCCESS;
+}
+/* ser_phy API function */
+uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer)
+{
+    if (m_spi_master_state != SER_PHY_STATE_MEMORY_REQUEST)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    //ser_phy_interrupts_disable();
+    CRITICAL_REGION_ENTER();
+    mp_rx_buffer       = p_buffer;
+    m_pend_rx_api_flag = true;
+    SET_Pend_SW_IRQ();
+    //ser_phy_interrupts_enable();
+    CRITICAL_REGION_EXIT();
+
+    return NRF_SUCCESS;
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
+{
+    if (m_spi_master_state != SER_PHY_STATE_DISABLED)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (events_handler == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    uint32_t err_code = NRF_SUCCESS;
+
+    m_spi_master_state        = SER_PHY_STATE_IDLE;
+    m_callback_events_handler = events_handler;
+    nrf_drv_spi_config_t spi_master_config = {
+        .sck_pin      = SER_PHY_SPI_MASTER_PIN_SCK,
+        .mosi_pin     = SER_PHY_SPI_MASTER_PIN_MOSI,
+        .miso_pin     = SER_PHY_SPI_MASTER_PIN_MISO,
+        .ss_pin       = SER_PHY_SPI_MASTER_PIN_SLAVE_SELECT,
+        .irq_priority = APP_IRQ_PRIORITY_MID,
+        .orc          = 0,
+        .frequency    = SER_PHY_SPI_FREQUENCY,
+        .mode         = NRF_DRV_SPI_MODE_0,
+        .bit_order    = NRF_DRV_SPI_BIT_ORDER_LSB_FIRST,
+    };
+    err_code = nrf_drv_spi_init(&m_spi_master, &spi_master_config,
+        ser_phy_spi_master_event_handler);
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    }
+
+    err_code = ser_phy_init_gpiote();
+    ser_phy_init_PendSV();
+    return err_code;
+}
+
+/* ser_phy API function */
+void ser_phy_close(void)
+{
+    m_spi_master_state = SER_PHY_STATE_DISABLED;
+
+    m_callback_events_handler = NULL;
+
+    buffer_release(&mp_tx_buffer, &m_tx_buf_len);
+    buffer_release(&mp_rx_buffer, &m_rx_buf_len);
+
+    m_tx_packet_length             = 0;
+    m_accumulated_tx_packet_length = 0;
+    m_current_tx_packet_length     = 0;
+
+    m_rx_packet_length             = 0;
+    m_accumulated_rx_packet_length = 0;
+    m_current_rx_packet_length     = 0;
+
+    ser_phy_deinit_gpiote();
+    nrf_drv_spi_uninit(&m_spi_master);
+}
+
+/* ser_phy API function */
+/* only PendSV may interact with ser_phy layer, other interrupts are internal */
+void ser_phy_interrupts_enable(void)
+{
+    NVIC_EnableIRQ(SW_IRQn);
+}
+
+/* ser_phy API function */
+void ser_phy_interrupts_disable(void)
+{
+    NVIC_DisableIRQ(SW_IRQn);
+}
+
+/** @} */

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_spi_slave.c

@@ -0,0 +1,608 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+/**@file
+ *
+ * @defgroup ser_phy_spi_phy_driver_slave ser_phy_nrf51_spi_slave.c
+ * @{
+ * @ingroup ser_phy_spi_phy_driver_slave
+ *
+ * @brief SPI_RAW PHY slave driver.
+ */
+
+#include <stddef.h>
+#include <string.h>
+
+#include "app_error.h"
+#include "app_util.h"
+#include "boards.h"
+#include "nrf_gpio.h"
+#include "nrf_drv_gpiote.h"
+#include "nrf_soc.h"
+#include "nrf_drv_spis.h"
+#include "ser_config.h"
+#include "ser_phy.h"
+#include "ser_phy_config_conn.h"
+#include "ser_phy_debug_conn.h"
+
+#define SER_PHY_SPI_DEF_CHARACTER 0xFF //SPI default character. Character clocked out in case of an ignored transaction
+#define SER_PHY_SPI_ORC_CHARACTER 0xFF //SPI over-read character. Character clocked out after an over-read of the transmit buffer
+
+static nrf_drv_spis_t m_spis = NRF_DRV_SPIS_INSTANCE(SER_PHY_SPI_SLAVE_INSTANCE);
+
+//SPI raw peripheral device configuration data
+typedef struct
+{
+    int32_t pin_req;       //SPI /REQ pin. -1 for not using
+    int32_t pin_rdy;       //SPI /RDY pin. -1 for not using
+    int32_t ppi_rdy_ch;    //SPI /RDY ppi ready channel
+    int32_t gpiote_rdy_ch; //SPI /RDY pin ready channel
+} spi_slave_raw_trasp_cfg_t;
+
+/**@brief States of the SPI transaction state machine. */
+typedef enum
+{
+    SPI_RAW_STATE_UNKNOWN,
+    SPI_RAW_STATE_SETUP_HEADER,
+    SPI_RAW_STATE_RX_HEADER,
+    SPI_RAW_STATE_MEM_REQUESTED,
+    SPI_RAW_STATE_RX_PAYLOAD,
+    SPI_RAW_STATE_TX_HEADER,
+    SPI_RAW_STATE_TX_PAYLOAD,
+} trans_state_t;
+
+#define _static static
+
+static spi_slave_raw_trasp_cfg_t m_spi_slave_raw_config;
+
+_static uint16_t m_accumulated_rx_packet_length;
+_static uint16_t m_rx_packet_length;
+_static uint16_t m_current_rx_frame_length;
+
+_static uint16_t m_accumulated_tx_packet_length;
+_static uint16_t m_tx_packet_length;
+_static uint16_t m_current_tx_frame_length;
+
+_static uint8_t m_header_rx_buffer[SER_PHY_HEADER_SIZE];
+_static uint8_t m_header_tx_buffer[SER_PHY_HEADER_SIZE];
+
+_static uint8_t m_frame_buffer[SER_PHY_SPI_MTU_SIZE];          //trash storage
+_static uint8_t m_zero_buffer[SER_PHY_SPI_MTU_SIZE] = {  0  }; //ROM'able declaration
+
+_static uint8_t * volatile       m_p_rx_buffer = NULL;
+_static const uint8_t * volatile m_p_tx_buffer = NULL;
+
+_static bool m_trash_payload_flag;
+_static bool m_buffer_reqested_flag;
+
+_static trans_state_t            m_trans_state      = SPI_RAW_STATE_UNKNOWN;
+_static ser_phy_events_handler_t m_ser_phy_callback = NULL;
+
+static void spi_slave_raw_assert(bool cond)
+{
+    APP_ERROR_CHECK_BOOL(cond);
+}
+
+static void callback_ser_phy_event(ser_phy_evt_t event)
+{
+    if (m_ser_phy_callback)
+    {
+        m_ser_phy_callback(event);
+    }
+}
+
+static void callback_memory_request(uint16_t size)
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_SLAVE_PHY_BUF_REQUEST(0);
+
+    event.evt_type                               = SER_PHY_EVT_RX_BUF_REQUEST;
+    event.evt_params.rx_buf_request.num_of_bytes = size;
+    callback_ser_phy_event(event);
+}
+
+static void callback_packet_received(uint8_t * pBuffer, uint16_t size)
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_SLAVE_PHY_PKT_RECEIVED(0);
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_RECEIVED;
+    event.evt_params.rx_pkt_received.num_of_bytes = size;
+    event.evt_params.rx_pkt_received.p_buffer     = pBuffer;
+    callback_ser_phy_event(event);
+}
+
+static void callback_packet_dropped()
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_SLAVE_PHY_PKT_DROPPED(0);
+
+    event.evt_type = SER_PHY_EVT_RX_PKT_DROPPED;
+    callback_ser_phy_event(event);
+}
+
+static void callback_packet_transmitted(void)
+{
+    ser_phy_evt_t event;
+
+    DEBUG_EVT_SPI_SLAVE_PHY_PKT_SENT(0);
+
+    event.evt_type = SER_PHY_EVT_TX_PKT_SENT;
+    callback_ser_phy_event(event);
+}
+
+/* Function computes current packet length */
+static uint16_t compute_current_frame_length(const uint16_t packet_length,
+                                             const uint16_t accumulated_packet_length)
+{
+    uint16_t current_packet_length = packet_length - accumulated_packet_length;
+
+    if (current_packet_length > SER_PHY_SPI_MTU_SIZE)
+    {
+        current_packet_length = SER_PHY_SPI_MTU_SIZE;
+    }
+
+    return current_packet_length;
+}
+
+static uint32_t header_get()
+{
+    uint32_t err_code;
+
+    err_code = nrf_drv_spis_buffers_set(&m_spis,
+                                        (uint8_t *) m_zero_buffer,
+                                        SER_PHY_HEADER_SIZE,
+                                        m_header_rx_buffer,
+                                        SER_PHY_HEADER_SIZE);
+    return err_code;
+}
+
+static uint32_t frame_get()
+{
+    uint32_t err_code;
+
+    m_current_rx_frame_length = compute_current_frame_length(m_rx_packet_length,
+                                                             m_accumulated_rx_packet_length);
+
+    if (!m_trash_payload_flag)
+    {
+        err_code =
+            nrf_drv_spis_buffers_set(&m_spis,
+                                     (uint8_t *) m_zero_buffer,
+                                     m_current_rx_frame_length,
+                                     &(m_p_rx_buffer[m_accumulated_rx_packet_length]),
+                                     m_current_rx_frame_length);
+    }
+    else
+    {
+        err_code = nrf_drv_spis_buffers_set(&m_spis,
+                                            (uint8_t *) m_zero_buffer,
+                                            m_current_rx_frame_length,
+                                            m_frame_buffer,
+                                            m_current_rx_frame_length);
+    }
+    return err_code;
+}
+
+static uint32_t header_send(uint16_t len)
+{
+    uint32_t err_code;
+
+    (void) uint16_encode(len, m_header_tx_buffer);
+    err_code =
+        nrf_drv_spis_buffers_set(&m_spis,
+                                 m_header_tx_buffer,
+                                 sizeof (m_header_tx_buffer),
+                                 m_header_rx_buffer,
+                                 sizeof (m_header_tx_buffer));
+    return err_code;
+}
+
+static uint32_t frame_send()
+{
+    uint32_t err_code;
+
+    m_current_tx_frame_length = compute_current_frame_length(m_tx_packet_length,
+                                                             m_accumulated_tx_packet_length);
+    err_code                     =
+        nrf_drv_spis_buffers_set(&m_spis,
+                                 (uint8_t *) &(m_p_tx_buffer[m_accumulated_tx_packet_length]),
+                                 m_current_tx_frame_length,
+                                 m_frame_buffer,
+                                 m_current_tx_frame_length);
+    return err_code;
+}
+
+static void set_ready_line(void)
+{
+    //toggle - this should go high - but toggle is unsafe
+    uint32_t rdy_task = nrf_drv_gpiote_out_task_addr_get(m_spi_slave_raw_config.pin_rdy);
+    *(uint32_t *)rdy_task = 1;
+    return;
+}
+
+static void set_request_line(void)
+{
+    //active low logic - set is 0
+    nrf_gpio_pin_clear(m_spi_slave_raw_config.pin_req);
+    DEBUG_EVT_SPI_SLAVE_RAW_REQ_SET(0);
+}
+
+static void clear_request_line(void)
+{
+    //active low logic - clear is 1
+    nrf_gpio_pin_set(m_spi_slave_raw_config.pin_req);
+    DEBUG_EVT_SPI_SLAVE_RAW_REQ_SET(0);
+}
+
+/**
+ * \brief Slave driver main state machine
+ * For UML graph, please refer to SDK documentation
+*/
+static void spi_slave_event_handle(nrf_drv_spis_event_t event)
+{
+    uint32_t        err_code = NRF_SUCCESS;
+    static uint16_t packetLength;
+
+    switch (m_trans_state)
+    {
+        case SPI_RAW_STATE_SETUP_HEADER:
+            m_trans_state = SPI_RAW_STATE_RX_HEADER;
+            err_code      = header_get();
+            break;
+
+        case SPI_RAW_STATE_RX_HEADER:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_RX_XFER_DONE(event.rx_amount);
+                spi_slave_raw_assert(event.rx_amount == SER_PHY_HEADER_SIZE);
+                packetLength = uint16_decode(m_header_rx_buffer);
+
+                if (packetLength != 0 )
+                {
+                    m_trans_state          = SPI_RAW_STATE_MEM_REQUESTED;
+                    m_buffer_reqested_flag = true;
+                    m_rx_packet_length     = packetLength;
+                    callback_memory_request(packetLength);
+                }
+                else
+                {
+                    if (m_p_tx_buffer)
+                    {
+                        clear_request_line();
+                        m_trans_state = SPI_RAW_STATE_TX_HEADER;
+                        err_code      = header_send(m_tx_packet_length);
+                    }
+                    else
+                    {
+                        //there is nothing to send - zero response facilitates pooling - but perhaps, it should be assert
+                        err_code = header_send(0);
+                    }
+                }
+            }
+
+            break;
+
+        case SPI_RAW_STATE_MEM_REQUESTED:
+
+            if (event.evt_type == NRF_DRV_SPIS_EVT_TYPE_MAX) //This is API dummy event
+            {
+                m_buffer_reqested_flag         = false;
+                m_trans_state                  = SPI_RAW_STATE_RX_PAYLOAD;
+                m_accumulated_rx_packet_length = 0;
+                err_code                       = frame_get();
+            }
+            break;
+
+        case SPI_RAW_STATE_RX_PAYLOAD:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_RX_XFER_DONE(event.rx_amount);
+                spi_slave_raw_assert(event.rx_amount == m_current_rx_frame_length);
+                m_accumulated_rx_packet_length += m_current_rx_frame_length;
+
+                if (m_accumulated_rx_packet_length < m_rx_packet_length )
+                {
+                    err_code = frame_get();
+                }
+                else
+                {
+                    spi_slave_raw_assert(m_accumulated_rx_packet_length == m_rx_packet_length);
+                    m_trans_state = SPI_RAW_STATE_RX_HEADER;
+                    err_code      = header_get();
+
+                    if (!m_trash_payload_flag)
+                    {
+                        callback_packet_received(m_p_rx_buffer, m_accumulated_rx_packet_length);
+                    }
+                    else
+                    {
+                        callback_packet_dropped();
+                    }
+                }
+            }
+            break;
+
+        case SPI_RAW_STATE_TX_HEADER:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_TX_XFER_DONE(event.tx_amount);
+                spi_slave_raw_assert(event.tx_amount == SER_PHY_HEADER_SIZE);
+                m_trans_state                  = SPI_RAW_STATE_TX_PAYLOAD;
+                m_accumulated_tx_packet_length = 0;
+                err_code                       = frame_send();
+            }
+
+            break;
+
+        case SPI_RAW_STATE_TX_PAYLOAD:
+
+            if (event.evt_type == NRF_DRV_SPIS_BUFFERS_SET_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_BUFFERS_SET(0);
+                set_ready_line();
+            }
+
+            if (event.evt_type == NRF_DRV_SPIS_XFER_DONE)
+            {
+                DEBUG_EVT_SPI_SLAVE_RAW_TX_XFER_DONE(event.tx_amount);
+                spi_slave_raw_assert(event.tx_amount == m_current_tx_frame_length);
+                m_accumulated_tx_packet_length += m_current_tx_frame_length;
+
+                if ( m_accumulated_tx_packet_length < m_tx_packet_length )
+                {
+                    err_code = frame_send();
+                }
+                else
+                {
+                    spi_slave_raw_assert(m_accumulated_tx_packet_length == m_tx_packet_length);
+                    //clear pointer before callback
+                    m_p_tx_buffer = NULL;
+                    callback_packet_transmitted();
+                    //spi slave TX transfer is possible only when RX is ready, so return to waiting for a header
+                    m_trans_state = SPI_RAW_STATE_RX_HEADER;
+                    err_code      = header_get();
+                }
+            }
+            break;
+
+        default:
+            err_code = NRF_ERROR_INVALID_STATE;
+            break;
+    }
+    APP_ERROR_CHECK(err_code);
+}
+
+static void spi_slave_gpiote_init(void)
+{
+    if (!nrf_drv_gpiote_is_init())
+    {
+        (void)nrf_drv_gpiote_init();
+    }
+    nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(true);
+    (void) nrf_drv_gpiote_out_init(m_spi_slave_raw_config.pin_rdy, &config);
+    (void) nrf_drv_gpiote_out_task_enable(m_spi_slave_raw_config.pin_rdy);
+    return;
+}
+
+static void spi_slave_ppi_init(void)
+{
+    uint32_t rdy_task = nrf_drv_gpiote_out_task_addr_get(m_spi_slave_raw_config.pin_rdy);
+    //Configure PPI channel  to clear /RDY line
+    NRF_PPI->CH[m_spi_slave_raw_config.ppi_rdy_ch].EEP = (uint32_t)(&NRF_SPIS1->EVENTS_END);
+    NRF_PPI->CH[m_spi_slave_raw_config.ppi_rdy_ch].TEP = rdy_task;
+
+    //this works only for channels 0..15 - but soft device is using 8-15 anyway
+    NRF_PPI->CHEN |= (1 << m_spi_slave_raw_config.ppi_rdy_ch);
+    return;
+}
+
+static void spi_slave_gpio_init(void)
+{
+    nrf_gpio_pin_set(m_spi_slave_raw_config.pin_req);
+    nrf_gpio_cfg_output(m_spi_slave_raw_config.pin_req);
+    nrf_gpio_pin_set(m_spi_slave_raw_config.pin_rdy);
+    nrf_gpio_cfg_output(m_spi_slave_raw_config.pin_rdy);
+}
+
+/* ser_phy API function */
+void ser_phy_interrupts_enable(void)
+{
+    (void)sd_nvic_EnableIRQ(m_spis.irq);
+}
+
+/* ser_phy API function */
+void ser_phy_interrupts_disable(void)
+{
+    (void)sd_nvic_DisableIRQ(m_spis.irq);
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer)
+{
+    uint32_t             status = NRF_SUCCESS;
+    nrf_drv_spis_event_t event;
+
+    ser_phy_interrupts_disable();
+
+    if (m_buffer_reqested_flag && (m_trans_state == SPI_RAW_STATE_MEM_REQUESTED))
+    {
+        m_p_rx_buffer = p_buffer;
+
+        if (m_p_rx_buffer)
+        {
+            m_trash_payload_flag = false;
+        }
+        else
+        {
+            m_trash_payload_flag = true;
+        }
+        event.evt_type  = NRF_DRV_SPIS_EVT_TYPE_MAX; //force transition with dummy event
+        event.rx_amount = 0;
+        event.tx_amount = 0;
+        spi_slave_event_handle(event);
+    }
+    else
+    {
+        status = NRF_ERROR_BUSY;
+    }
+    ser_phy_interrupts_enable();
+
+    return status;
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    uint32_t status = NRF_SUCCESS;
+
+    if ( p_buffer == NULL || num_of_bytes == 0)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    ser_phy_interrupts_disable();
+
+    if ( m_p_tx_buffer == NULL)
+    {
+        m_tx_packet_length = num_of_bytes;
+        m_p_tx_buffer      = p_buffer;
+        set_request_line();
+    }
+    else
+    {
+        status = NRF_ERROR_BUSY;
+    }
+    ser_phy_interrupts_enable();
+
+    return status;
+}
+
+/* ser_phy API function */
+uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
+{
+    uint32_t              err_code;
+    nrf_drv_spis_config_t spi_slave_config;
+    nrf_drv_spis_event_t  event;
+
+    if (m_trans_state != SPI_RAW_STATE_UNKNOWN)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (events_handler == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    //one ppi channel and one gpiote channel are used to drive RDY line
+    m_spi_slave_raw_config.pin_req       = SER_PHY_SPI_SLAVE_REQ_PIN;
+    m_spi_slave_raw_config.pin_rdy       = SER_PHY_SPI_SLAVE_RDY_PIN;
+    m_spi_slave_raw_config.ppi_rdy_ch    = SER_PHY_SPI_PPI_RDY_CH;
+    m_spi_slave_raw_config.gpiote_rdy_ch = SER_PHY_SPI_GPIOTE_RDY_CH;
+
+    spi_slave_gpio_init();
+    spi_slave_gpiote_init();
+    spi_slave_ppi_init();
+
+    spi_slave_config.miso_pin         = SER_PHY_SPI_SLAVE_MISO_PIN;
+    spi_slave_config.mosi_pin         = SER_PHY_SPI_SLAVE_MOSI_PIN;
+    spi_slave_config.sck_pin          = SER_PHY_SPI_SLAVE_SCK_PIN;
+    spi_slave_config.csn_pin          = SER_PHY_SPI_SLAVE_SS_PIN;
+    spi_slave_config.mode             = NRF_DRV_SPIS_MODE_0;
+    spi_slave_config.bit_order        = NRF_DRV_SPIS_BIT_ORDER_LSB_FIRST;
+    spi_slave_config.def              = SER_PHY_SPI_DEF_CHARACTER;
+    spi_slave_config.orc              = SER_PHY_SPI_ORC_CHARACTER;
+    spi_slave_config.irq_priority     = APP_IRQ_PRIORITY_LOWEST;
+    spi_slave_config.miso_drive       = NRF_DRV_SPIS_DEFAULT_MISO_DRIVE;
+    //use /CS pullup because state of the line might be undefined when master redefines PIO lines
+    spi_slave_config.csn_pullup       = NRF_GPIO_PIN_PULLUP;
+
+    //keep /CS high when init
+    nrf_gpio_cfg_input(spi_slave_config.csn_pin, NRF_GPIO_PIN_PULLUP);
+
+    err_code = nrf_drv_spis_init(&m_spis, &spi_slave_config, spi_slave_event_handle);
+    APP_ERROR_CHECK(err_code);
+
+    if (err_code == NRF_SUCCESS)
+    {
+        m_ser_phy_callback = events_handler;
+
+        m_trans_state   = SPI_RAW_STATE_SETUP_HEADER;
+        event.evt_type  = NRF_DRV_SPIS_EVT_TYPE_MAX; //force transition for dummy event
+        event.rx_amount = 0;
+        event.tx_amount = 0;
+        spi_slave_event_handle(event);
+
+    }
+    return err_code;
+}
+
+/* ser_phy API function */
+void ser_phy_close(void)
+{
+    nrf_drv_spis_uninit(&m_spis);
+    m_ser_phy_callback = NULL;
+    m_trans_state      = SPI_RAW_STATE_UNKNOWN;
+}

COMPONENTS/serialization/common/transport/ser_phy/ser_phy_uart.c

@@ -0,0 +1,455 @@
+/**
+ * Copyright (c) 2014 - 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 "ser_phy.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "nordic_common.h"
+#include "nrf.h"
+#include "nrf_error.h"
+#include "nrf_gpio.h"
+#include "app_util.h"
+#include "app_uart.h"
+#include "app_error.h"
+#include "nrf_drv_uart.h"
+
+#ifdef SER_CONNECTIVITY
+#include "ser_phy_config_conn.h"
+#else
+#include "ser_phy_config_app.h"
+#endif /* SER_CONNECTIVITY */
+
+#include "boards.h"
+
+#define SER_UART_IRQ UART0_IRQn
+
+static uint8_t * mp_tx_stream;                         /**< Pointer to Tx data */
+static uint16_t  m_tx_stream_length;                   /**< Length of Tx data including SER_PHY
+                                                        *   header */
+static uint16_t  m_tx_stream_index;                    /**< Byte index in Tx data */
+static uint8_t   m_tx_length_buf[SER_PHY_HEADER_SIZE]; /**< Buffer for header of Tx packet */
+
+static uint8_t * mp_rx_stream;                         /**< Pointer to Rx buffer */
+static uint16_t  m_rx_stream_length;                   /**< Length of Rx data including SER_PHY
+                                                        *   header*/
+static uint16_t  m_rx_stream_index;                    /**< Byte index in Rx data */
+static uint8_t   m_rx_length_buf[SER_PHY_HEADER_SIZE]; /**< Buffer for header of Rx packet */
+static uint8_t   m_rx_drop_buf[1];                     /**< 1-byte buffer used to trash incoming
+                                                        *   data */
+static uint8_t   m_rx_byte;                            /**< Rx byte passed from low-level driver */
+
+static ser_phy_events_handler_t m_ser_phy_event_handler; /**< Event handler for upper layer */
+static ser_phy_evt_t            m_ser_phy_rx_event;      /**< Rx event for upper layer
+                                                          *   notification */
+static ser_phy_evt_t            m_ser_phy_tx_event;      /**< Tx event for upper layer
+                                                          *   notification */
+
+static bool m_other_side_active = false; /* Flag indicating that the other side is running */
+
+/**
+ *@breif UART configuration structure, values are defined in SER_PHY config files:
+ *  ser_phy_config_conn_nrf51.h for connectivity and ser_phy_config_app_nrf51.h for application.
+ */
+static const app_uart_comm_params_t comm_params =
+{
+    .rx_pin_no  = SER_PHY_UART_RX,
+    .tx_pin_no  = SER_PHY_UART_TX,
+    .rts_pin_no = SER_PHY_UART_RTS,
+    .cts_pin_no = SER_PHY_UART_CTS,
+    //Below values are defined in ser_config.h common for application and connectivity
+    .flow_control = SER_PHY_UART_FLOW_CTRL,
+    .use_parity   = SER_PHY_UART_PARITY,
+    .baud_rate    = SER_PHY_UART_BAUDRATE
+};
+
+/** FUNCTION DECLARATIONS */
+
+static __INLINE void callback_ser_phy_event(ser_phy_evt_t event);
+static __INLINE void callback_packet_received(void);
+static __INLINE void callback_packet_sent(void);
+static __INLINE void callback_mem_request(void);
+static __INLINE void callback_hw_error(uint32_t error_src);
+
+static void ser_phy_uart_tx(void);
+static void ser_phy_uart_rx(uint8_t rx_byte);
+static void ser_phy_uart_evt_callback(app_uart_evt_t * uart_evt);
+
+
+/** STATIC FUNCTION DEFINITIONS */
+
+/**
+ *@brief Callback for calling ser phy event handler to notify higher layer with appropriate event.
+ * Handler is called only wen it was previously registered.
+ */
+static __INLINE void callback_ser_phy_event(ser_phy_evt_t event)
+{
+    if (m_ser_phy_event_handler)
+    {
+        m_ser_phy_event_handler(event);
+    }
+    return;
+}
+
+/**
+ *@brief Callback for notifying upper layer that either a packet was succesfully received or it was
+ * dropped.
+ */
+static __INLINE void callback_packet_received(void)
+{
+    if (mp_rx_stream == m_rx_drop_buf)
+    {
+        m_ser_phy_rx_event.evt_type = SER_PHY_EVT_RX_PKT_DROPPED;
+    }
+    else
+    {
+        m_ser_phy_rx_event.evt_type = SER_PHY_EVT_RX_PKT_RECEIVED;
+        m_ser_phy_rx_event.evt_params.rx_pkt_received.num_of_bytes =
+            m_rx_stream_index - SER_PHY_HEADER_SIZE;
+        m_ser_phy_rx_event.evt_params.rx_pkt_received.p_buffer =
+            mp_rx_stream;
+    }
+
+    mp_rx_stream       = NULL;
+    m_rx_stream_length = 0;
+    m_rx_stream_index  = 0;
+
+    callback_ser_phy_event(m_ser_phy_rx_event);
+}
+
+/**
+ *@brief Callback for notifying upper layer that a packet was succesfully transmitted
+ */
+static __INLINE void callback_packet_sent(void)
+{
+    mp_tx_stream       = NULL;
+    m_tx_stream_length = 0;
+    m_tx_stream_index  = 0;
+
+    m_ser_phy_tx_event.evt_type = SER_PHY_EVT_TX_PKT_SENT;
+
+    callback_ser_phy_event(m_ser_phy_tx_event);
+}
+
+/**
+ *@brief Callback for requesting from upper layer memory for an incomming packet.
+ */
+static __INLINE void callback_mem_request(void)
+{
+    m_rx_stream_length          = uint16_decode(m_rx_length_buf) + SER_PHY_HEADER_SIZE;
+    m_ser_phy_rx_event.evt_type = SER_PHY_EVT_RX_BUF_REQUEST;
+    m_ser_phy_rx_event.evt_params.rx_buf_request.num_of_bytes =
+        m_rx_stream_length - SER_PHY_HEADER_SIZE;
+
+    callback_ser_phy_event(m_ser_phy_rx_event);
+}
+
+/**
+ *@brief Callback for notifying upper layer of a HW error that occured.
+ */
+static __INLINE void callback_hw_error(uint32_t error_src)
+{
+    mp_rx_stream                = NULL;
+    m_rx_stream_length          = 0;
+    m_rx_stream_index           = 0;
+    m_ser_phy_rx_event.evt_type = SER_PHY_EVT_HW_ERROR;
+
+    //Pass error source to upper layer
+    m_ser_phy_rx_event.evt_params.hw_error.error_code = error_src;
+    callback_ser_phy_event(m_ser_phy_rx_event);
+}
+
+/**
+ *@brief Function for handling Tx procedure.
+ */
+static void ser_phy_uart_tx(void)
+{
+    if (mp_tx_stream != NULL)
+    {
+        bool     tx_done_flag = false;       /**< Local flag for indicating that TX is completed */
+        uint32_t err_code     = NRF_SUCCESS; /**< Error code for storing result of app_uart_put */
+
+        //Blocking TXRDY interrupt is done to avoid interrupting when this procedure is
+        //triggered from main context
+#ifdef UARTE_IN_USE
+        NRF_UARTE0->INTENCLR = (UARTE_INTENSET_ENDTX_Set << UARTE_INTENSET_ENDTX_Pos);
+#else
+        NRF_UART0->INTENCLR = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
+#endif
+        //Notify upper layer if whole packet has been transmitted
+        if (m_tx_stream_index == m_tx_stream_length)
+        {
+            callback_packet_sent();
+            tx_done_flag = true;
+        }
+        //First transmit 2 bytes of packet length
+        else if (m_tx_stream_index < SER_PHY_HEADER_SIZE)
+        {
+            err_code = app_uart_put(m_tx_length_buf[m_tx_stream_index]);
+        }
+        //Then transmit payload
+        else if (m_tx_stream_index < m_tx_stream_length)
+        {
+            err_code = app_uart_put(mp_tx_stream[m_tx_stream_index - SER_PHY_HEADER_SIZE]);
+        }
+
+        //Increment index only if byte was sent without errors
+        if ((err_code == NRF_SUCCESS) && !tx_done_flag)
+        {
+            m_tx_stream_index++;
+        }
+
+        //Unblock TXRDY interrupts
+#ifdef UARTE_IN_USE
+        NRF_UARTE0->INTENSET = (UARTE_INTENSET_ENDTX_Set << UARTE_INTENSET_ENDTX_Pos);
+#else
+        NRF_UART0->INTENSET = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
+#endif
+    }
+
+}
+
+/**
+ *@brief Function for handling Rx procedure.
+ */
+static void ser_phy_uart_rx(uint8_t rx_byte)
+{
+
+    if (mp_rx_stream == NULL )
+    {
+        //Receive length value and request rx buffer from higher layer
+        if (m_rx_stream_index < SER_PHY_HEADER_SIZE)
+        {
+            m_rx_length_buf[m_rx_stream_index++] = rx_byte;
+
+            if (m_rx_stream_index == SER_PHY_HEADER_SIZE)
+            {
+                //Block RXRDY interrupts at this point to not handle incoming bytes until upper
+                //layer provides memory for payload
+#ifdef UARTE_IN_USE
+                NRF_UARTE0->INTENCLR = (UARTE_INTENCLR_ENDRX_Clear << UARTE_INTENCLR_ENDRX_Pos);
+#else
+                NRF_UART0->INTENCLR = (UART_INTENCLR_RXDRDY_Clear << UART_INTENCLR_RXDRDY_Pos);
+#endif
+                //Request rx buffer from upper layer
+                callback_mem_request();
+            }
+        }
+    }
+    else if (m_rx_stream_index < m_rx_stream_length)
+    {
+        //Receive or drop payload
+        if (mp_rx_stream == m_rx_drop_buf)
+        {
+            //Drop incoming data to the one-element drop buffer
+            *mp_rx_stream = rx_byte;
+            m_rx_stream_index++;
+        }
+        else
+        {
+            mp_rx_stream[m_rx_stream_index - SER_PHY_HEADER_SIZE] = rx_byte;
+            m_rx_stream_index++;
+        }
+    }
+
+    //Process RX packet, notify higher layer
+    if (m_rx_stream_index == m_rx_stream_length)
+    {
+        callback_packet_received();
+    }
+}
+
+/**
+ *@brief Callback for processing events from low-level UART driver.
+ */
+static void ser_phy_uart_evt_callback(app_uart_evt_t * uart_evt)
+{
+    if (uart_evt == NULL)
+    {
+        return;
+    }
+
+    switch (uart_evt->evt_type)
+    {
+        case APP_UART_COMMUNICATION_ERROR:
+
+            //Process error only if this is parity or overrun error.
+            //Break and framing error is always present when app side is not active
+            if (uart_evt->data.error_communication &
+                (UART_ERRORSRC_PARITY_Msk | UART_ERRORSRC_OVERRUN_Msk))
+            {
+                callback_hw_error(uart_evt->data.error_communication);
+            }
+            break;
+
+        case APP_UART_TX_EMPTY:
+            ser_phy_uart_tx();
+            break;
+
+        case APP_UART_DATA:
+
+            //After first reception disable pulldown - it was only needed before start
+            //of the other side
+            if (!m_other_side_active)
+            {
+                nrf_gpio_cfg_input(comm_params.rx_pin_no, NRF_GPIO_PIN_NOPULL);
+                m_other_side_active = true;
+            }
+
+            m_rx_byte = uart_evt->data.value;
+            ser_phy_uart_rx(m_rx_byte);
+            break;
+
+        default:
+            APP_ERROR_CHECK(NRF_ERROR_INTERNAL);
+            break;
+    }
+}
+
+/** API FUNCTIONS */
+
+uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    if (events_handler == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+
+    //Check if function was not called before
+    if (m_ser_phy_event_handler != NULL)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    //Configure UART and register handler
+    //uart_evt_handler is used to handle events produced by low-level uart driver
+    APP_UART_INIT(&comm_params, ser_phy_uart_evt_callback, UART_IRQ_PRIORITY, err_code);
+
+//    //Pull down Rx pin until another side gets up to avoid receiving false bytes due to glitches
+//    //on Rx line
+//    nrf_gpio_cfg_input(comm_params.rx_pin_no, NRF_GPIO_PIN_PULLDOWN);
+
+    m_ser_phy_event_handler = events_handler;
+
+    //If intialization did not go alright return error
+    if (err_code != NRF_SUCCESS)
+    {
+        return NRF_ERROR_INVALID_PARAM;
+    }
+
+    return err_code;
+}
+
+
+
+uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
+{
+    if (p_buffer == NULL)
+    {
+        return NRF_ERROR_NULL;
+    }
+    else if (num_of_bytes == 0)
+    {
+        return NRF_ERROR_INVALID_PARAM;
+    }
+
+    //Check if there is no ongoing transmission at the moment
+    if ((mp_tx_stream == NULL) && (m_tx_stream_length == 0) && (m_tx_stream_index == 0))
+    {
+        (void) uint16_encode(num_of_bytes, m_tx_length_buf);
+        mp_tx_stream       = (uint8_t *)p_buffer;
+        m_tx_stream_length = num_of_bytes + SER_PHY_HEADER_SIZE;
+
+        //Call tx procedure to start transmission of a packet
+        ser_phy_uart_tx();
+    }
+    else
+    {
+        return NRF_ERROR_BUSY;
+    }
+
+    return NRF_SUCCESS;
+}
+
+uint32_t ser_phy_rx_buf_set(uint8_t * p_buffer)
+{
+
+    if (m_ser_phy_rx_event.evt_type != SER_PHY_EVT_RX_BUF_REQUEST)
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (p_buffer != NULL)
+    {
+        mp_rx_stream = p_buffer;
+    }
+    else
+    {
+        mp_rx_stream = m_rx_drop_buf;
+    }
+
+    //Unblock RXRDY interrupts as higher layer has responded (with a valid or NULL pointer)
+#ifdef UARTE_IN_USE
+    NRF_UARTE0->INTENSET = (UARTE_INTENSET_ENDRX_Set << UARTE_INTENSET_ENDRX_Pos);
+#else
+    NRF_UART0->INTENSET = (UART_INTENSET_RXDRDY_Set << UART_INTENSET_RXDRDY_Pos);
+#endif
+    return NRF_SUCCESS;
+}
+
+void ser_phy_close(void)
+{
+    m_ser_phy_event_handler = NULL;
+    (void)app_uart_close();
+}
+
+void ser_phy_interrupts_enable(void)
+{
+    NVIC_EnableIRQ(SER_UART_IRQ);
+}
+
+void ser_phy_interrupts_disable(void)
+{
+    NVIC_DisableIRQ(SER_UART_IRQ);
+}
+

COMPONENTS/serialization/common/transport/ser_phy_debug_comm.h

@@ -0,0 +1,204 @@
+/**
+ * Copyright (c) 2014 - 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.
+ * 
+ */
+
+#ifndef SER_PHY_DEBUG_COMM_H__
+#define SER_PHY_DEBUG_COMM_H__
+
+#ifndef SER_PHY_HCI_DEBUG_ENABLE
+
+// empty definitions here
+#define DEBUG_EVT_HCI_PHY_EVT_TX_PKT_SENT(data)
+#define DEBUG_EVT_HCI_PHY_EVT_BUF_REQUEST(data)
+#define DEBUG_EVT_HCI_PHY_EVT_RX_PKT_RECEIVED(data)
+#define DEBUG_EVT_HCI_PHY_EVT_RX_PKT_DROPPED(data)
+#define DEBUG_EVT_HCI_PHY_EVT_TX_ERROR(data)
+#define DEBUG_EVT_SLIP_PACKET_TX(data)
+#define DEBUG_EVT_SLIP_ACK_TX(data)
+#define DEBUG_EVT_SLIP_PACKET_TXED(data)
+#define DEBUG_EVT_SLIP_ACK_TXED(data)
+#define DEBUG_EVT_SLIP_PACKET_RXED(data)
+#define DEBUG_EVT_SLIP_ACK_RXED(data)
+#define DEBUG_EVT_SLIP_ERR_RXED(data)
+#define DEBUG_EVT_TIMEOUT(data)
+#define DEBUG_HCI_RETX(data)
+#define DEBUG_EVT_MAIN_BUSY(data)
+#define DEBUG_EVT_TX_REQ(data)
+
+#else
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//Low level hardware events
+typedef enum
+{
+    HCI_PHY_EVT_TX_PKT_SENT,
+    HCI_PHY_EVT_BUF_REQUEST,
+    HCI_PHY_EVT_RX_PKT_RECEIVED,
+    HCI_PHY_EVT_RX_PKT_DROPPED,
+    HCI_PHY_EVT_TX_ERROR,
+    HCI_SLIP_EVT_PACKET_TX,
+    HCI_SLIP_EVT_ACK_TX,
+    HCI_SLIP_EVT_PACKET_TXED,
+    HCI_SLIP_EVT_ACK_TXED,
+    HCI_SLIP_EVT_PACKET_RXED,
+    HCI_SLIP_EVT_ACK_RXED,
+    HCI_SLIP_EVT_ERR_RXED,
+    HCI_TIMER_EVT_TIMEOUT,
+    HCI_RETX,
+    HCI_MAIN_BUSY,
+    HCI_TX_REQ,
+    HCI_PHY_EVT_MAX
+} hci_dbg_evt_type_t;
+
+
+//Low level hardware event definition
+typedef struct
+{
+    hci_dbg_evt_type_t   evt;
+    uint32_t              data;
+} hci_dbg_evt_t;
+
+typedef void (*hci_dbg_event_handler_t)(hci_dbg_evt_t event);
+
+void debug_init(hci_dbg_event_handler_t evt_callback);
+
+void debug_evt(hci_dbg_evt_type_t evt, uint32_t data);
+
+
+#define DEBUG_EVT(event_type, data)    \
+do {                            \
+    debug_evt(event_type, data);       \
+} while (0);
+
+
+#define DEBUG_EVT_HCI_PHY_EVT_TX_PKT_SENT(data)      \
+do {                                                 \
+    DEBUG_EVT(HCI_PHY_EVT_TX_PKT_SENT, data);        \
+} while (0);
+
+
+#define DEBUG_EVT_HCI_PHY_EVT_BUF_REQUEST(data)       \
+do {                                                  \
+    DEBUG_EVT(HCI_PHY_EVT_BUF_REQUEST, data);         \
+} while (0);
+
+
+#define DEBUG_EVT_HCI_PHY_EVT_RX_PKT_RECEIVED(data)   \
+do {                                                  \
+    DEBUG_EVT(HCI_PHY_EVT_RX_PKT_RECEIVED, data);     \
+} while (0);
+
+
+#define DEBUG_EVT_HCI_PHY_EVT_RX_PKT_DROPPED(data)    \
+do {                                                  \
+    DEBUG_EVT(HCI_PHY_EVT_RX_PKT_DROPPED, data);      \
+} while (0);
+
+#define DEBUG_EVT_HCI_PHY_EVT_TX_ERROR(data)          \
+do {                                                  \
+    DEBUG_EVT(HCI_PHY_EVT_TX_ERROR, data);            \
+} while (0);
+
+#define DEBUG_EVT_SLIP_PACKET_TX(data)                \
+do {                                                  \
+    DEBUG_EVT(HCI_SLIP_EVT_PACKET_TX, data);          \
+} while (0);
+
+#define DEBUG_EVT_SLIP_ACK_TX(data)                   \
+do {                                                  \
+    DEBUG_EVT(HCI_SLIP_EVT_ACK_TX, data);             \
+} while (0);
+
+#define DEBUG_EVT_SLIP_PACKET_TXED(data)              \
+do {                                                  \
+    DEBUG_EVT(HCI_SLIP_EVT_PACKET_TXED, data);        \
+} while (0);
+
+#define DEBUG_EVT_SLIP_ACK_TXED(data)                 \
+do {                                                  \
+    DEBUG_EVT(HCI_SLIP_EVT_ACK_TXED, data);           \
+} while (0);
+
+#define DEBUG_EVT_SLIP_PACKET_RXED(data)              \
+do {                                                  \
+    DEBUG_EVT(HCI_SLIP_EVT_PACKET_RXED, data);        \
+} while (0);
+
+#define DEBUG_EVT_SLIP_ACK_RXED(data)                 \
+do {                                                  \
+    DEBUG_EVT(HCI_SLIP_EVT_ACK_RXED, data);           \
+} while (0);
+
+#define DEBUG_EVT_SLIP_ERR_RXED(data)                 \
+do {                                                  \
+    DEBUG_EVT(HCI_SLIP_EVT_ERR_RXED, data);           \
+} while (0);
+
+#define DEBUG_EVT_TIMEOUT(data)                       \
+do {                                                  \
+    DEBUG_EVT(HCI_TIMER_EVT_TIMEOUT, data);           \
+} while (0);
+
+#define DEBUG_HCI_RETX(data)                          \
+do {                                                  \
+    DEBUG_EVT(HCI_RETX, data);                        \
+} while (0);
+
+#define DEBUG_EVT_MAIN_BUSY(data)                     \
+do {                                                  \
+    DEBUG_EVT(HCI_MAIN_BUSY, data);                   \
+} while (0);
+
+#define DEBUG_EVT_TX_REQ(data)                        \
+do {                                                  \
+    DEBUG_EVT(HCI_TX_REQ, data);                      \
+} while (0);
+
+#endif  // SER_PHY_HCI_DEBUG_ENABLE
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // SER_PHY_DEBUG_COMM_H__