aa8a8df07c
The license for wireless/spirit is added to the LICENSE file Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2088 lines
56 KiB
C
2088 lines
56 KiB
C
/******************************************************************************
|
|
* drivers/wireless/spirit/lib/spirit_pktcommon.c
|
|
*
|
|
* Copyright(c) 2015 STMicroelectronics
|
|
* Author: VMA division - AMS
|
|
* Version 3.2.2 08-July-2015
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of STMicroelectronics nor the names of its
|
|
* contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
* Included Files
|
|
******************************************************************************/
|
|
|
|
#include <assert.h>
|
|
|
|
#include "spirit_pktcommon.h"
|
|
#include "spirit_spi.h"
|
|
|
|
/******************************************************************************
|
|
* Public Functions
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_controllen
|
|
*
|
|
* Description:
|
|
* Sets the CONTROL field length for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* ctrllen - Length of CONTROL field in bytes.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_controllen(FAR struct spirit_library_s *spirit,
|
|
enum pkt_ctrllen_e ctrllen)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_CONTROL_LENGTH(ctrllen));
|
|
|
|
/* Read the PCKTCTRL4 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKTCTRL4_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Set the control length */
|
|
|
|
regval &= ~PCKTCTRL4_CONTROL_LEN_MASK;
|
|
regval |= (uint8_t)ctrllen;
|
|
|
|
/* Write the new value on the PCKTCTRL4 register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKTCTRL4_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_controllen
|
|
*
|
|
* Description:
|
|
* Returns the CONTROL field length for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Control field length.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_controllen(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PCKTCTRL4 register value */
|
|
|
|
spirit_reg_read(spirit, PCKTCTRL4_BASE, ®val, 1);
|
|
|
|
/* Rebuild and return value */
|
|
|
|
return (regval & PCKTCTRL4_CONTROL_LEN_MASK);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_preamblen
|
|
*
|
|
* Description:
|
|
* Sets the PREAMBLE field Length mode for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* preamblen - Length of PREAMBLE field in bytes.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_preamblen(FAR struct spirit_library_s *spirit,
|
|
enum pkt_preamblen_e preamblen)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_PREAMBLE_LENGTH(preamblen));
|
|
|
|
/* Read the PCKTCTRL2 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Set the preamble length */
|
|
|
|
regval &= ~PCKTCTRL2_PREAMBLE_LENGTH_MASK;
|
|
regval |= (uint8_t)preamblen;
|
|
|
|
/* Write the new value to the PCKTCTRL2 register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_preamblen
|
|
*
|
|
* Description:
|
|
* Returns the PREAMBLE field Length mode for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Preamble field length in bytes.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_preamblen(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PCKTCTRL2 register value */
|
|
|
|
spirit_reg_read(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
|
|
/* Rebuild and return value */
|
|
|
|
return ((regval & PCKTCTRL2_PREAMBLE_LENGTH_MASK) >> 3) + 1;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pkt_set_synclen
|
|
*
|
|
* Description:
|
|
* Sets the SYNC field Length for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* synclen - Length of SYNC field in bytes.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pkt_set_synclen(FAR struct spirit_library_s *spirit,
|
|
enum pkt_synlen_e synclen)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_SYNC_LENGTH(synclen));
|
|
|
|
/* Read the PCKTCTRL2 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Set the sync length */
|
|
|
|
regval &= ~PCKTCTRL2_SYNC_LENGTH_MASK;
|
|
regval |= (uint8_t)synclen;
|
|
|
|
/* Write the new value to the PCKTCTRL2 register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_synclen
|
|
*
|
|
* Description:
|
|
* Returns the SYNC field Length for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Sync field length in bytes.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_synclen(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PCKTCTRL2 register value */
|
|
|
|
spirit_reg_read(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
|
|
/* Rebuild and return value */
|
|
|
|
return ((regval & PCKTCTRL2_SYNC_LENGTH_MASK) >> 1) + 1;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_fixvarlen
|
|
*
|
|
* Description:
|
|
* Sets fixed or variable payload length mode for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* fixvarlen - Variable or fixed length.
|
|
* PKT_FIXED_LENGTH_VAR -> variable (the length is extracted
|
|
* from the received packet).
|
|
* PKT_FIXED_LENGTH_FIX -> fix (the length is set by PCKTLEN0
|
|
* and PCKTLEN1).
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_fixvarlen(FAR struct spirit_library_s *spirit,
|
|
enum pkt_fixvar_len_e fixvarlen)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_FIX_VAR_LENGTH(fixvarlen));
|
|
|
|
/* Read the PCKTCTRL2 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Set fixed or variable address mode */
|
|
|
|
regval &= ~PCKTCTRL2_FIX_VAR_LEN_MASK;
|
|
regval |= (uint8_t)fixvarlen;
|
|
|
|
/* Write the new value to the PCKTCTRL2 register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKTCTRL2_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_crcfilter
|
|
*
|
|
* Description:
|
|
* Enables or Disables the filtering on CRC.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for CRC_CHECK. This parameter can be S_ENABLE or
|
|
* S_DISABLE.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_crcfilter(FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Read the PCKT_FLT_OPTIONS register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Modify the register value: enable or disable the CRC filtering */
|
|
|
|
if (newstate == S_ENABLE)
|
|
{
|
|
regval |= PCKT_FLT_OPTIONS_CRC_CHECK_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PCKT_FLT_OPTIONS_CRC_CHECK_MASK;
|
|
}
|
|
|
|
/* Write the PCKT_FLT_OPTIONS register value */
|
|
|
|
ret = spirit_reg_write(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_isenabled_crcfilter
|
|
*
|
|
* Description:
|
|
* Returns the CRC filtering enable bit.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* CRC filtering state.
|
|
*
|
|
******************************************************************************/
|
|
|
|
enum spirit_functional_state_e
|
|
spirit_pktcommon_isenabled_crcfilter(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PCKT_FLT_OPTIONS register value */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
|
|
/* Check the CRC filtering bit */
|
|
|
|
if (regval & PCKT_FLT_OPTIONS_CRC_CHECK_MASK)
|
|
{
|
|
return S_ENABLE;
|
|
}
|
|
else
|
|
{
|
|
return S_DISABLE;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_crcmode
|
|
*
|
|
* Description:
|
|
* Sets the CRC mode for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* crcmode - Length of CRC field in bytes.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_crcmode(FAR struct spirit_library_s *spirit,
|
|
enum pkt_crcmode_e crcmode)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_CRC_MODE(crcmode));
|
|
|
|
/* Read the PCKTCTRL1 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKTCTRL1_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Build data to write setting the CRC mode */
|
|
|
|
regval &= ~PCKTCTRL1_CRC_MODE_MASK;
|
|
regval |= (uint8_t)crcmode;
|
|
|
|
/* Write the new value to the PCKTCTRL1 register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKTCTRL1_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_crcmode
|
|
*
|
|
* Description:
|
|
* Returns the CRC mode for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Crc mode.
|
|
*
|
|
******************************************************************************/
|
|
|
|
enum pkt_crcmode_e
|
|
spirit_pktcommon_get_crcmode(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PCKTCTRL1 register */
|
|
|
|
spirit_reg_read(spirit, PCKTCTRL1_BASE, ®val, 1);
|
|
|
|
/* Rebuild and return value */
|
|
|
|
return (enum pkt_crcmode_e) (regval & 0xe0);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_whitening
|
|
*
|
|
* Description:
|
|
* Enables or Disables WHITENING for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for WHITENING mode.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_whitening(FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Read the PCKTCTRL1 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKTCTRL1_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Build data to write: set or reset the whitening enable bit */
|
|
|
|
if (newstate == S_ENABLE)
|
|
{
|
|
regval |= PCKTCTRL1_WHIT_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PCKTCTRL1_WHIT_MASK;
|
|
}
|
|
|
|
/* Write the new value to the PCKTCTRL1 register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKTCTRL1_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_fec
|
|
*
|
|
* Description:
|
|
* Enables or Disables FEC for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for FEC mode.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_fec(FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Read the PCKTCTRL1 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKTCTRL1_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Build data to write: set or reset the FEC enable bit */
|
|
|
|
if (newstate == S_ENABLE)
|
|
{
|
|
regval |= PCKTCTRL1_FEC_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PCKTCTRL1_FEC_MASK;
|
|
}
|
|
|
|
/* Write data to the PCKTCTRL1 register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKTCTRL1_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_syncword
|
|
*
|
|
* Description:
|
|
* Sets a specific SYNC word for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* syncwordno - SYNC word number to be set.
|
|
* syncword - SYNC word.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_syncword(FAR struct spirit_library_s *spirit,
|
|
enum spirit_pktsyncword_e syncwordno,
|
|
uint8_t syncword)
|
|
{
|
|
uint8_t regaddr;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_SYNCWORD(syncwordno));
|
|
|
|
/* Set the specified address */
|
|
|
|
switch (syncwordno)
|
|
{
|
|
case PKT_SYNC_WORD_1:
|
|
regaddr = SYNC1_BASE;
|
|
break;
|
|
|
|
case PKT_SYNC_WORD_2:
|
|
regaddr = SYNC2_BASE;
|
|
break;
|
|
|
|
case PKT_SYNC_WORD_3:
|
|
regaddr = SYNC3_BASE;
|
|
break;
|
|
|
|
default:
|
|
regaddr = SYNC4_BASE;
|
|
break;
|
|
}
|
|
|
|
/* Write value to the selected register */
|
|
|
|
return spirit_reg_write(spirit, regaddr, &syncword, 1);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_syncword
|
|
*
|
|
* Description:
|
|
* Returns a specific SYNC word for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* syncwordno - SYNC word number to be get.
|
|
*
|
|
* Returned Value:
|
|
* Sync word x.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_syncword(FAR struct spirit_library_s *spirit,
|
|
enum spirit_pktsyncword_e syncwordno)
|
|
{
|
|
uint8_t regaddr;
|
|
uint8_t regval;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_SYNCWORD(syncwordno));
|
|
|
|
/* Set the specified address */
|
|
|
|
switch (syncwordno)
|
|
{
|
|
case PKT_SYNC_WORD_1:
|
|
regaddr = SYNC1_BASE;
|
|
break;
|
|
|
|
case PKT_SYNC_WORD_2:
|
|
regaddr = SYNC2_BASE;
|
|
break;
|
|
case PKT_SYNC_WORD_3:
|
|
regaddr = SYNC3_BASE;
|
|
break;
|
|
|
|
default:
|
|
regaddr = SYNC4_BASE;
|
|
break;
|
|
}
|
|
|
|
/* Read the selected register value */
|
|
|
|
spirit_reg_read(spirit, regaddr, ®val, 1);
|
|
|
|
/* Returns the read value */
|
|
|
|
return regval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_syncwords
|
|
*
|
|
* Description:
|
|
* Sets multiple SYNC words for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* syncwords - SYNC words to be set with format: 0x|SYNC1|SYNC2|SYNC3|SYNC4|.
|
|
* synclen - SYNC length in bytes. The 32bit word passed will be stored in
|
|
* the SYNCx registers from the MSb until the number of bytes in
|
|
* synclen has been stored.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_syncwords(FAR struct spirit_library_s *spirit,
|
|
uint32_t syncwords,
|
|
enum pkt_synlen_e synclen)
|
|
{
|
|
uint8_t regval[4];
|
|
int i;
|
|
|
|
/* Split the 32-bit value in 4 8-bit values */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
if (i < ((3 - synclen) >> 1))
|
|
{
|
|
regval[i] = 0;
|
|
}
|
|
else
|
|
{
|
|
regval[i] = (uint8_t)(syncwords >> (8 * i));
|
|
}
|
|
}
|
|
|
|
/* Write SYNC value to the SYNCx registers */
|
|
|
|
return spirit_reg_write(spirit, SYNC4_BASE, regval, 4);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_syncwords
|
|
*
|
|
* Description:
|
|
* Returns multiple SYNC words for SPIRIT packets.
|
|
*
|
|
* Input Parameters:
|
|
* spiri - Reference to a Spirit library state structure instance
|
|
* synclen - SYNC length in bytes. The 32bit word passed will be stored in
|
|
* the SYNCx registers from the MSb until the number of bytes in
|
|
* synclen has been stored.
|
|
*
|
|
* Returned Value:
|
|
* Sync words. The format of the read 32 bit word is
|
|
* 0x|SYNC1|SYNC2|SYNC3|SYNC4|.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint32_t spirit_pktcommon_get_syncwords(FAR struct spirit_library_s *spirit,
|
|
enum pkt_synlen_e synclen)
|
|
{
|
|
uint8_t regval[4];
|
|
uint32_t syncword = 0;
|
|
int i;
|
|
|
|
/* Read the SYNCx registers value */
|
|
|
|
spirit_reg_read(spirit, SYNC4_BASE, regval, 4);
|
|
|
|
/* Rebuild the SYNC words */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
if (i > 2 - (synclen >> 1))
|
|
{
|
|
syncword |= regval[i] << (8 * i);
|
|
}
|
|
}
|
|
|
|
/* Return SYNC words */
|
|
|
|
return syncword;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_varlen
|
|
*
|
|
* Description:
|
|
* Returns the variable length width (in number of bits).
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Variable length width in bits.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_varlen(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PCKTCTRL3 register value */
|
|
|
|
spirit_reg_read(spirit, PCKTCTRL3_BASE, ®val, 1);
|
|
|
|
/* Rebuild and return value */
|
|
|
|
return (regval & PCKTCTRL3_LEN_WID_MASK) + 1;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_txdestaddr
|
|
*
|
|
* Description:
|
|
* Sets the destination address for the Tx packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* txdestaddr - Destination address.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_txdestaddr(FAR struct spirit_library_s *spirit,
|
|
uint8_t txdestaddr)
|
|
{
|
|
/* Write value to PCKT_FLT_GOALS_SOURCE_ADDR register */
|
|
|
|
return spirit_reg_write(spirit,
|
|
PCKT_FLT_GOALS_SOURCE_ADDR_BASE, &txdestaddr, 1);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_txdestaddr
|
|
*
|
|
* Description:
|
|
* Returns the settled destination address.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Transmitted destination address.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_txdestaddr(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read value from the PCKT_FLT_GOALS_SOURCE_ADDR register */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_GOALS_SOURCE_ADDR_BASE, ®val, 1);
|
|
|
|
/* Return value */
|
|
|
|
return regval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_nodeaddress
|
|
*
|
|
* Description:
|
|
* Sets the node my address. When the filtering on my address is on, if the
|
|
* destination address extracted from the received packet is equal to the
|
|
* content of the my address, then the packet is accepted (this is the
|
|
* address of the node).
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* srcaddr - Address of the present node.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_nodeaddress(FAR struct spirit_library_s *spirit,
|
|
uint8_t srcaddr)
|
|
{
|
|
/* Write value to the PCKT_FLT_GOALS_TX_ADDR register */
|
|
|
|
return spirit_reg_write(spirit, PCKT_FLT_GOALS_TX_ADDR_BASE, &srcaddr, 1);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_nodeaddress
|
|
*
|
|
* Description:
|
|
* Returns the address of the present node.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* My address (address of this node).
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_nodeaddress(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read value from the PCKT_FLT_GOALS_TX_ADDR register */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_GOALS_TX_ADDR_BASE, ®val, 1);
|
|
|
|
/* Return value */
|
|
|
|
return regval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_bcastaddr
|
|
*
|
|
* Description:
|
|
* Sets the broadcast address. If the destination address extracted from the
|
|
* received packet is equal to the content of the BROADCAST_ADDR register,
|
|
* then the packet is accepted.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* bcastaddr - Broadcast address.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_bcastaddr(FAR struct spirit_library_s *spirit,
|
|
uint8_t bcastaddr)
|
|
{
|
|
/* Write value to the PCKT_FLT_GOALS_BROADCAST register */
|
|
|
|
return spirit_reg_write(spirit,
|
|
PCKT_FLT_GOALS_BROADCAST_BASE, &bcastaddr, 1);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_bcastaddr
|
|
*
|
|
* Description:
|
|
* Returns the broadcast address.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Broadcast address.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_bcastaddr(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read value from the PCKT_FLT_GOALS_BROADCAST register */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_GOALS_BROADCAST_BASE, ®val, 1);
|
|
|
|
/* Return value */
|
|
|
|
return regval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_mcastaddr
|
|
*
|
|
* Description:
|
|
* Sets the multicast address. When the multicast filtering is on, if the
|
|
* destination address extracted from the received packet is equal to the
|
|
* content of the MULTICAST_ADDR register, then the packet is accepted.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* mcastaddr - Multicast address.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_mcastaddr(FAR struct spirit_library_s *spirit,
|
|
uint8_t mcastaddr)
|
|
{
|
|
/* Write value to the PCKT_FLT_GOALS_MULTICAST register */
|
|
|
|
return spirit_reg_write(spirit,
|
|
PCKT_FLT_GOALS_MULTICAST_BASE, &mcastaddr, 1);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_mcastaddr
|
|
*
|
|
* Description:
|
|
* Returns the multicast address.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Multicast address.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_mcastaddr(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read value from the PCKT_FLT_GOALS_MULTICAST register */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_GOALS_MULTICAST_BASE, ®val, 1);
|
|
|
|
/* Return value */
|
|
|
|
return regval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_ctrlmask
|
|
*
|
|
* Description:
|
|
* Sets the control mask. The 1 bits of the CONTROL_MASK indicate the bits
|
|
* to be used in filtering. (All 0s no filtering)
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* mask Control mask.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_ctrlmask(FAR struct spirit_library_s *spirit,
|
|
uint32_t mask)
|
|
{
|
|
uint8_t regval[4];
|
|
|
|
/* Split the 32-bit value in 4 8-bit values */
|
|
|
|
regval[0] = (uint8_t)mask;
|
|
regval[1] = (uint8_t)(mask >> 8);
|
|
regval[2] = (uint8_t)(mask >> 16);
|
|
regval[3] = (uint8_t)(mask >> 24);
|
|
|
|
/* Write values to the CKT_FLT_GOALS_CONTROLx_MASK registers */
|
|
|
|
return spirit_reg_write(spirit,
|
|
PCKT_FLT_GOALS_CONTROL0_MASK_BASE, regval, 4);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_ctrlmask
|
|
*
|
|
* Description:
|
|
* Returns the control mask. The 1 bits of the CONTROL_MASK indicate the
|
|
* bits to be used in filtering. (All 0s no filtering)
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Control mask.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint32_t spirit_pktcommon_get_ctrlmask(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval[4];
|
|
uint32_t ctrlmask = 0;
|
|
int i;
|
|
|
|
/* Read the PCKT_FLT_GOALS_CONTROLx_MASK registers */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_GOALS_CONTROL0_MASK_BASE, regval, 4);
|
|
|
|
/* Rebuild the control mask value on a 32-bit integer variable */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
ctrlmask |= (uint32_t)regval[i] << (8 * i);
|
|
}
|
|
|
|
/* Return value */
|
|
|
|
return ctrlmask;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_ctrlref
|
|
*
|
|
* Description:
|
|
* Sets the control field reference. If the bits enabled by the CONTROL_MASK
|
|
* match the ones of the control fields extracted from the received packet
|
|
* then the packet is accepted.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* reference - Control reference.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_ctrlref(FAR struct spirit_library_s *spirit,
|
|
uint32_t reference)
|
|
{
|
|
uint8_t regval[4];
|
|
|
|
/* Split the 32-bit value in 4 8-bit values */
|
|
|
|
regval[0] = (uint8_t)reference;
|
|
regval[1] = (uint8_t)(reference >> 8);
|
|
regval[2] = (uint8_t)(reference >> 16);
|
|
regval[3] = (uint8_t)(reference >> 24);
|
|
|
|
/* Write values to the CKT_FLT_GOALS_CONTROLx_FIELD registers */
|
|
|
|
return spirit_reg_write(spirit,
|
|
PCKT_FLT_GOALS_CONTROL0_FIELD_BASE, regval, 4);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_ctrlref
|
|
*
|
|
* Description:
|
|
* Returns the control field reference.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Control reference.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint32_t spirit_pktcommon_get_ctrlref(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval[4];
|
|
uint32_t ctrlref = 0;
|
|
int i;
|
|
|
|
/* Read the PCKT_FLT_GOALS_CONTROLx_FIELD registers */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_GOALS_CONTROL0_FIELD_BASE, regval, 4);
|
|
|
|
/* Rebuild the control mask value on a 32-bit integer variable */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
ctrlref |= ((uint32_t) regval[i]) << (8 * i);
|
|
}
|
|
|
|
/* Return value */
|
|
|
|
return ctrlref;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_txctrl
|
|
*
|
|
* Description:
|
|
* Sets the TX control field.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* txctrl - Tx control field.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_txctrl(FAR struct spirit_library_s *spirit,
|
|
uint32_t txctrl)
|
|
{
|
|
uint8_t regval[4];
|
|
|
|
/* Split the 32-bit value in 4 8-bit values */
|
|
|
|
regval[3] = (uint8_t)txctrl;
|
|
regval[2] = (uint8_t)(txctrl >> 8);
|
|
regval[1] = (uint8_t)(txctrl >> 16);
|
|
regval[0] = (uint8_t)(txctrl >> 24);
|
|
|
|
/* Write value to the TX_CTRL_FIELDx register */
|
|
|
|
return spirit_reg_write(spirit, TX_CTRL_FIELD3_BASE, regval, 4);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_txctrl
|
|
*
|
|
* Description:
|
|
* Returns the Tx control field.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Control field of the transmitted packet.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint32_t spirit_pktcommon_get_txctrl(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval[4];
|
|
uint32_t ctrlfield = 0;
|
|
int i;
|
|
|
|
/* Read the TX_CTRL_FIELDx registers */
|
|
|
|
spirit_reg_read(spirit, TX_CTRL_FIELD3_BASE, regval, 4);
|
|
|
|
/* Rebuild value: build a 32-bit value from the read bytes */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
ctrlfield |= ((uint32_t) regval[i]) << (8 * (3 - i));
|
|
}
|
|
|
|
/* Return value */
|
|
|
|
return ctrlfield;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_destaddr_filter
|
|
*
|
|
* Description:
|
|
* If enabled RX packet is accepted if its destination address matches with
|
|
* My address.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for DEST_VS_SOURCE_ADDRESS.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_destaddr_filter(
|
|
FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Modify the register value: set or reset the TX source address control */
|
|
|
|
ret = spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Set or reset the DESTINATION vs TX enabling bit */
|
|
|
|
if (newstate == S_ENABLE)
|
|
{
|
|
regval |= PCKT_FLT_OPTIONS_DEST_VS_TX_ADDR_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PCKT_FLT_OPTIONS_DEST_VS_TX_ADDR_MASK;
|
|
}
|
|
|
|
/* Write the new value to the PCKT_FLT_OPTIONS register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_mcastaddr_filter
|
|
*
|
|
* Description:
|
|
* If enabled RX packet is accepted if its destination address matches with
|
|
* multicast address.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for DEST_VS_MULTICAST_ADDRESS.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_mcastaddr_filter(
|
|
FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Read the PCKT_FLT_OPTIONS register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Enable or disable the filtering option */
|
|
|
|
if (newstate == S_ENABLE)
|
|
{
|
|
regval |= PCKT_FLT_OPTIONS_DEST_VS_MULTICAST_ADDR_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PCKT_FLT_OPTIONS_DEST_VS_MULTICAST_ADDR_MASK;
|
|
}
|
|
|
|
/* Write the new value to the PCKT_FLT_OPTIONS register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_bcastaddr_filter
|
|
*
|
|
* Description:
|
|
* If enabled RX packet is accepted if its destination address matches with
|
|
* broadcast address.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for DEST_VS_BROADCAST_ADDRESS.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_bcastaddr_filter(
|
|
FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Read the register value */
|
|
|
|
ret = spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Enable or disable the filtering option */
|
|
|
|
if (newstate == S_ENABLE)
|
|
{
|
|
regval |= PCKT_FLT_OPTIONS_DEST_VS_BROADCAST_ADDR_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PCKT_FLT_OPTIONS_DEST_VS_BROADCAST_ADDR_MASK;
|
|
}
|
|
|
|
/* Write the new value to the PCKT_FLT_OPTIONS register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_isenabled_destaddr_filter
|
|
*
|
|
* Description:
|
|
* Returns the enable bit of the my address filtering.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* S_ENABLE or S_DISABLE.
|
|
*
|
|
******************************************************************************/
|
|
|
|
enum spirit_functional_state_e
|
|
spirit_pktcommon_isenabled_destaddr_filter(
|
|
FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the register value */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
|
|
/* Gets the enable/disable bit in form of enum spirit_functional_state_e
|
|
* type
|
|
*/
|
|
|
|
if (regval & 0x08)
|
|
{
|
|
return S_ENABLE;
|
|
}
|
|
else
|
|
{
|
|
return S_DISABLE;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_isenabled_mcastaddr_filter
|
|
*
|
|
* Description:
|
|
* Returns the enable bit of the multicast address filtering.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* S_ENABLE or S_DISABLE.
|
|
*
|
|
******************************************************************************/
|
|
|
|
enum spirit_functional_state_e
|
|
spirit_pktcommon_isenabled_mcastaddr_filter(
|
|
FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the register value */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
|
|
/* Get the enable/disable bit in form of enum spirit_functional_state_e
|
|
* type
|
|
*/
|
|
|
|
if (regval & 0x04)
|
|
{
|
|
return S_ENABLE;
|
|
}
|
|
else
|
|
{
|
|
return S_DISABLE;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_isenabled_bcastaddr_filter
|
|
*
|
|
* Description:
|
|
* Returns the enable bit of the broadcast address filtering.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* S_ENABLE or S_DISABLE.
|
|
*
|
|
******************************************************************************/
|
|
|
|
enum spirit_functional_state_e
|
|
spirit_pktcommon_isenabled_bcastaddr_filter(
|
|
FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the register value */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
|
|
/* Get the enable/disable bit in form of enum spirit_functional_state_e
|
|
* type
|
|
*/
|
|
|
|
if (regval & 0x02)
|
|
{
|
|
return S_ENABLE;
|
|
}
|
|
else
|
|
{
|
|
return S_DISABLE;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_rxdestaddr
|
|
*
|
|
* Description:
|
|
* Returns the destination address of the received packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Destination address of the received address.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_rxdestaddr(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the RX_ADDR_FIELD0 register value */
|
|
|
|
spirit_reg_read(spirit, RX_ADDR_FIELD0_BASE, ®val, 1);
|
|
|
|
/* Return value */
|
|
|
|
return regval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_rxctrl
|
|
*
|
|
* Description:
|
|
* Returns the control field of the received packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Received control field.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint32_t spirit_pktcommon_get_rxctrl(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval[4];
|
|
uint32_t ctrlfield = 0;
|
|
int i;
|
|
|
|
/* Read the PCKT_FLT_GOALS_CONTROLx_MASK registers */
|
|
|
|
spirit_reg_read(spirit, RX_CTRL_FIELD0_BASE, regval, 4);
|
|
|
|
/* Rebuild the control mask value on a 32-bit integer variable */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
ctrlfield |= ((uint32_t)regval[i]) << (8 * i);
|
|
}
|
|
|
|
/* Returns value */
|
|
|
|
return ctrlfield;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_rxcrc
|
|
*
|
|
* Description:
|
|
* Returns the CRC field of the received packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* crc - Array in which the CRC field has to be stored.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_get_rxcrc(FAR struct spirit_library_s *spirit,
|
|
FAR uint8_t *crc)
|
|
{
|
|
enum pkt_crcmode_e crcmode;
|
|
uint8_t regval[3];
|
|
uint8_t crclen;
|
|
int ret;
|
|
int i;
|
|
|
|
/* Gets the CRC mode in enum pkt_crcmode_e enum */
|
|
|
|
crcmode = spirit_pktcommon_get_crcmode(spirit);
|
|
|
|
/* Cast to FAR uint8_t */
|
|
|
|
crclen = (uint8_t)crcmode;
|
|
|
|
/* Obtains the real length: see the @ref enum pkt_crcmode_e enumeration */
|
|
|
|
crclen >>= 5;
|
|
if (crclen >= 3)
|
|
{
|
|
crclen--;
|
|
}
|
|
|
|
/* Read the CRC_FIELDx registers value */
|
|
|
|
ret = spirit_reg_read(spirit, CRC_FIELD2_BASE, regval, 3);
|
|
if (ret >= 0)
|
|
{
|
|
/* Sets the array to be returned */
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
if (i < crclen)
|
|
{
|
|
crc[i] = regval[2 - i];
|
|
}
|
|
else
|
|
{
|
|
crc[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_rxautoack
|
|
*
|
|
* Description:
|
|
* Sets the AUTO ACKNOLEDGEMENT mechanism on the receiver. When the feature
|
|
* is enabled and a data packet has been correctly received, then an
|
|
* acknowledgement packet is sent back to the originator of the received
|
|
* packet. If the PIGGYBACKING bit is also set, payload data will be read
|
|
* from the FIFO; otherwise an empty packet is sent only containing the
|
|
* source and destination addresses and the sequence number of the packet
|
|
* being acknowledged.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* autoack - New state for autoack.
|
|
* piggyback - New state for autoack.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_rxautoack(FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e autoack,
|
|
enum spirit_functional_state_e piggyback)
|
|
{
|
|
uint8_t regval[2];
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(autoack));
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(piggyback));
|
|
|
|
/* Check if piggybacking is enabled and autoack is disabled */
|
|
|
|
DEBUGASSERT(!(piggyback == S_ENABLE && autoack == S_DISABLE));
|
|
|
|
/* Read the PROTOCOL[1:0] registers value */
|
|
|
|
ret = spirit_reg_read(spirit, PROTOCOL1_BASE, regval, 2);
|
|
if (ret >= 0)
|
|
{
|
|
/* Sets the specified LLP option */
|
|
|
|
/* Autoack setting */
|
|
|
|
if (autoack == S_ENABLE)
|
|
{
|
|
regval[1] |= PROTOCOL0_AUTO_ACK_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval[1] &= (~PROTOCOL0_AUTO_ACK_MASK);
|
|
}
|
|
|
|
/* Piggybacking setting */
|
|
|
|
if (piggyback == S_ENABLE)
|
|
{
|
|
regval[0] |= PROTOCOL1_PIGGYBACKING_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval[0] &= (~PROTOCOL1_PIGGYBACKING_MASK);
|
|
}
|
|
|
|
/* Write data to the PROTOCOL[1:0] registers */
|
|
|
|
ret = spirit_reg_write(spirit, PROTOCOL1_BASE, regval, 2);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_txautoack
|
|
*
|
|
* Description:
|
|
* Sets the AUTO ACKNOLEDGEMENT mechanism on the transmitter. On the
|
|
* transmitter side, the NACK_TX field can be used to require or not an
|
|
* acknowledgment for each individual packet: if NACK_TX is set to "1" then
|
|
* acknowledgment will not be required; if NACK_TX is set to "0" then
|
|
* acknowledgment will be required.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for TX_AUTOACK.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_txautoack(FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Read value from the PROTOCOL0 register */
|
|
|
|
ret = spirit_reg_read(spirit, PROTOCOL0_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Enables or disables the ack requirement option */
|
|
|
|
if (newstate == S_DISABLE)
|
|
{
|
|
regval |= PROTOCOL0_NACK_TX_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PROTOCOL0_NACK_TX_MASK;
|
|
}
|
|
|
|
/* Write value to the PROTOCOL0 register */
|
|
|
|
ret = spirit_reg_write(spirit, PROTOCOL0_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_txseqno
|
|
*
|
|
* Description:
|
|
* Sets the TX sequence number to be used to start counting.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* seqno - New value for Tx seq number reload.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_txseqno(FAR struct spirit_library_s *spirit,
|
|
uint8_t seqno)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_SEQ_NUMBER_RELOAD(seqno));
|
|
|
|
/* Read value from the PROTOCOL2 register */
|
|
|
|
ret = spirit_reg_read(spirit, PROTOCOL2_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
regval &= 0xe7;
|
|
regval |= (seqno << 3);
|
|
|
|
/* Write value to the PROTOCOL2 register */
|
|
|
|
ret = spirit_reg_write(spirit, PROTOCOL2_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_set_maxretx
|
|
*
|
|
* Description:
|
|
* Set the maximum number of TX retries (from 0 to 15).
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* seqno - New value for Tx seq number reload.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_set_maxretx(FAR struct spirit_library_s *spirit,
|
|
enum spirit_maxretx_e maxretx)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_PKT_MAXRETX(maxretx));
|
|
|
|
/* Read the PROTOCOL0 register value */
|
|
|
|
ret = spirit_reg_read(spirit, PROTOCOL0_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Build the value to be written */
|
|
|
|
regval &= ~PROTOCOL0_NMAX_RETX_MASK;
|
|
regval |= maxretx;
|
|
|
|
/* Write value to the PROTOCOL0 register */
|
|
|
|
ret = spirit_reg_write(spirit, PROTOCOL0_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_maxretx
|
|
*
|
|
* Description:
|
|
* Returns the max number of automatic retransmission.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Max number of retransmissions.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_maxretx(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PROTOCOL0 register value */
|
|
|
|
spirit_reg_read(spirit, PROTOCOL0_BASE, ®val, 1);
|
|
|
|
/* Build the value to be written */
|
|
|
|
return ((regval & PROTOCOL0_NMAX_RETX_MASK) >> 4);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_txackreq
|
|
*
|
|
* Description:
|
|
* Returns the TX ACK request
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Max number of retransmissions.
|
|
*
|
|
******************************************************************************/
|
|
|
|
enum spirit_functional_state_e
|
|
spirit_pktcommon_get_txackreq(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the PROTOCOL0 register value */
|
|
|
|
spirit_reg_read(spirit, RX_PCKT_INFO_BASE, ®val, 1);
|
|
|
|
/* Build the value to be written */
|
|
|
|
return (enum spirit_functional_state_e)
|
|
((regval & TX_PCKT_INFO_NACK_RX) >> 2);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_rxsrcaddr
|
|
*
|
|
* Description:
|
|
* Returns the source address of the received packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Source address of the received packet.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_rxsrcaddr(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the RX_ADDR_FIELD1 register value */
|
|
|
|
spirit_reg_read(spirit, RX_ADDR_FIELD1_BASE, ®val, 1);
|
|
|
|
/* Returns value */
|
|
|
|
return regval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_rxseqno
|
|
*
|
|
* Description:
|
|
* Returns the sequence number of the received packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Received Sequence number.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_rxseqno(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the RX_PCKT_INFO register value */
|
|
|
|
spirit_reg_read(spirit, RX_PCKT_INFO_BASE, ®val, 1);
|
|
|
|
/* Obtains and returns the sequence number */
|
|
|
|
return regval & 0x03;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_rxnak
|
|
*
|
|
* Description:
|
|
* Returns the Nack bit of the received packet
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Value of the Nack bit.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_rxnak(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the RX_PCKT_INFO register value */
|
|
|
|
spirit_reg_read(spirit, RX_PCKT_INFO_BASE, ®val, 1);
|
|
|
|
/* Obtains and returns the RX nack bit */
|
|
|
|
return (regval >> 2) & 0x01;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_txseqno
|
|
*
|
|
* Description:
|
|
* Returns the sequence number of the transmitted packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Sequence number of the transmitted packet.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_txseqno(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the TX_PCKT_INFO register value */
|
|
|
|
spirit_reg_read(spirit, TX_PCKT_INFO_BASE, ®val, 1);
|
|
|
|
/* Obtains and returns the TX sequence number */
|
|
|
|
return (regval >> 4) & 0x07;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_get_nretx
|
|
*
|
|
* Description:
|
|
* Returns the number of retransmission done on the transmitted packet.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* Number of retransmissions done until now.
|
|
*
|
|
******************************************************************************/
|
|
|
|
uint8_t spirit_pktcommon_get_nretx(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the TX_PCKT_INFO register value */
|
|
|
|
spirit_reg_read(spirit, TX_PCKT_INFO_BASE, ®val, 1);
|
|
|
|
/* Obtains and returns the number of retransmission done */
|
|
|
|
return (regval & 0x0f);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_enable_ctrl_filter
|
|
*
|
|
* Description:
|
|
* If enabled RX packet is accepted only if the masked control field matches
|
|
* the masked control field reference (CONTROL_MASK & CONTROL_FIELD_REF ==
|
|
* CONTROL_MASK & RX_CONTROL_FIELD).
|
|
*
|
|
* NOTE: This filtering control is enabled by default but the control mask is
|
|
* by default set to 0. As a matter of fact the user has to enable the
|
|
* control filtering bit after the packet initialization because the packet
|
|
* initialization routine disables it.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
* newstate - New state for Control filtering enable bit.
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success; a negated errno value on failure.
|
|
*
|
|
******************************************************************************/
|
|
|
|
int spirit_pktcommon_enable_ctrl_filter(FAR struct spirit_library_s *spirit,
|
|
enum spirit_functional_state_e newstate)
|
|
{
|
|
uint8_t regval;
|
|
int ret;
|
|
|
|
/* Check the parameters */
|
|
|
|
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
|
|
|
|
/* Modify the register value: set or reset the control bit filtering */
|
|
|
|
ret = spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
if (ret >= 0)
|
|
{
|
|
/* Set or reset the CONTROL filtering enabling bit */
|
|
|
|
if (newstate == S_ENABLE)
|
|
{
|
|
regval |= PCKT_FLT_OPTIONS_CONTROL_FILTERING_MASK;
|
|
}
|
|
else
|
|
{
|
|
regval &= ~PCKT_FLT_OPTIONS_CONTROL_FILTERING_MASK;
|
|
}
|
|
|
|
/* Write the new value to the PCKT_FLT_OPTIONS register */
|
|
|
|
ret = spirit_reg_write(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Name: spirit_pktcommon_isenabled_ctrl_filter
|
|
*
|
|
* Description:
|
|
* Returns the enable bit of the control field filtering.
|
|
*
|
|
* Input Parameters:
|
|
* spirit - Reference to a Spirit library state structure instance
|
|
*
|
|
* Returned Value:
|
|
* S_ENABLE or S_DISABLE.
|
|
*
|
|
******************************************************************************/
|
|
|
|
enum spirit_functional_state_e
|
|
spirit_pktcommon_isenabled_ctrl_filter(FAR struct spirit_library_s *spirit)
|
|
{
|
|
uint8_t regval;
|
|
|
|
/* Read the register value */
|
|
|
|
spirit_reg_read(spirit, PCKT_FLT_OPTIONS_BASE, ®val, 1);
|
|
|
|
/* Gets the enable/disable bit in form of enum spirit_functional_state_e
|
|
* type
|
|
*/
|
|
|
|
if (regval & PCKT_FLT_OPTIONS_CONTROL_FILTERING_MASK)
|
|
{
|
|
return S_ENABLE;
|
|
}
|
|
else
|
|
{
|
|
return S_DISABLE;
|
|
}
|
|
}
|