/****************************************************************************** * drivers/wireless/spirit/lib/spirit_pktcommon.c * Configuration and management of the common features of SPIRIT packets. * * Copyright(c) 2015 STMicroelectronics * Author: VMA division - AMS * Version 3.2.2 08-July-2015 * * Adapted for NuttX by: * Author: Gregory Nutt * * 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 #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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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, 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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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 */ (void)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; } }