/* 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_rx_buf_set(uint8_t * p_buffer)
{
uint32_t status = NRF_SUCCESS;
spi_slave_evt_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 = SPI_SLAVE_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;
}
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_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_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;
}
