/****************************************************************************** * \attention * * <h2><center>© COPYRIGHT 2020 STMicroelectronics</center></h2> * * Licensed under ST MYLIBERTY SOFTWARE LICENSE AGREEMENT (the "License"); * You may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * www.st.com/myliberty * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, * AND SPECIFICALLY DISCLAIMING THE IMPLIED WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ /* * PROJECT: ST25R391x firmware * Revision: * LANGUAGE: ISO C99 */ /*! \file rfal_iso15693_2.c * * \author Ulrich Herrmann * * \brief Implementation of ISO-15693-2 * */ /* ****************************************************************************** * INCLUDES ****************************************************************************** */ #include "rfal_iso15693_2.h" #include "rfal_crc.h" #include "utils.h" /* ****************************************************************************** * ENABLE SWITCH ****************************************************************************** */ #ifndef RFAL_FEATURE_NFCV #define RFAL_FEATURE_NFCV false /* NFC-V module configuration missing. Disabled by default */ #endif #if RFAL_FEATURE_NFCV /* ****************************************************************************** * LOCAL MACROS ****************************************************************************** */ #define ISO_15693_DEBUG(...) /*!< Macro for the log method */ /* ****************************************************************************** * LOCAL DEFINES ****************************************************************************** */ #define ISO15693_DAT_SOF_1_4 0x21 /* LSB constants */ #define ISO15693_DAT_EOF_1_4 0x04 #define ISO15693_DAT_00_1_4 0x02 #define ISO15693_DAT_01_1_4 0x08 #define ISO15693_DAT_10_1_4 0x20 #define ISO15693_DAT_11_1_4 0x80 #define ISO15693_DAT_SOF_1_256 0x81 #define ISO15693_DAT_EOF_1_256 0x04 #define ISO15693_DAT_SLOT0_1_256 0x02 #define ISO15693_DAT_SLOT1_1_256 0x08 #define ISO15693_DAT_SLOT2_1_256 0x20 #define ISO15693_DAT_SLOT3_1_256 0x80 #define ISO15693_PHY_DAT_MANCHESTER_1 0xaaaa #define ISO15693_PHY_BIT_BUFFER_SIZE 1000 /*!< size of the receiving buffer. Might be adjusted if longer datastreams are expected. */ /* ****************************************************************************** * LOCAL VARIABLES ****************************************************************************** */ static iso15693PhyConfig_t iso15693PhyConfig; /*!< current phy configuration */ /* ****************************************************************************** * LOCAL FUNCTION PROTOTYPES ****************************************************************************** */ static ReturnCode iso15693PhyVCDCode1Of4(const uint8_t data, uint8_t* outbuffer, uint16_t maxOutBufLen, uint16_t* outBufLen); static ReturnCode iso15693PhyVCDCode1Of256(const uint8_t data, uint8_t* outbuffer, uint16_t maxOutBufLen, uint16_t* outBufLen); /* ****************************************************************************** * GLOBAL FUNCTIONS ****************************************************************************** */ ReturnCode iso15693PhyConfigure(const iso15693PhyConfig_t* config, const struct iso15693StreamConfig ** needed_stream_config ) { static struct iso15693StreamConfig stream_config = { /* MISRA 8.9 */ .useBPSK = 0, /* 0: subcarrier, 1:BPSK */ .din = 5, /* 2^5*fc = 423750 Hz: divider for the in subcarrier frequency */ .dout = 7, /*!< 2^7*fc = 105937 : divider for the in subcarrier frequency */ .report_period_length = 3, /*!< 8=2^3 the length of the reporting period */ }; /* make a copy of the configuration */ ST_MEMCPY( (uint8_t*)&iso15693PhyConfig, (const uint8_t*)config, sizeof(iso15693PhyConfig_t)); if ( config->speedMode <= 3U) { /* If valid speed mode adjust report period accordingly */ stream_config.report_period_length = (3U - (uint8_t)config->speedMode); } else { /* If invalid default to normal (high) speed */ stream_config.report_period_length = 3; } *needed_stream_config = &stream_config; return ERR_NONE; } ReturnCode iso15693PhyGetConfiguration(iso15693PhyConfig_t* config) { ST_MEMCPY(config, &iso15693PhyConfig, sizeof(iso15693PhyConfig_t)); return ERR_NONE; } ReturnCode iso15693VCDCode(uint8_t* buffer, uint16_t length, bool sendCrc, bool sendFlags, bool picopassMode, uint16_t *subbit_total_length, uint16_t *offset, uint8_t* outbuf, uint16_t outBufSize, uint16_t* actOutBufSize) { ReturnCode err = ERR_NONE; uint8_t eof, sof; uint8_t transbuf[2]; uint16_t crc = 0; ReturnCode (*txFunc)(const uint8_t data, uint8_t* outbuffer, uint16_t maxOutBufLen, uint16_t* outBufLen); uint8_t crc_len; uint8_t* outputBuf; uint16_t outputBufSize; crc_len = (uint8_t)((sendCrc)?2:0); *actOutBufSize = 0; if (ISO15693_VCD_CODING_1_4 == iso15693PhyConfig.coding) { sof = ISO15693_DAT_SOF_1_4; eof = ISO15693_DAT_EOF_1_4; txFunc = iso15693PhyVCDCode1Of4; *subbit_total_length = ( ( 1U /* SOF */ + ((length + (uint16_t)crc_len) * 4U) + 1U) /* EOF */ ); if (outBufSize < 5U) { /* 5 should be safe: enough for sof + 1byte data in 1of4 */ return ERR_NOMEM; } } else { sof = ISO15693_DAT_SOF_1_256; eof = ISO15693_DAT_EOF_1_256; txFunc = iso15693PhyVCDCode1Of256; *subbit_total_length = ( ( 1U /* SOF */ + ((length + (uint16_t)crc_len) * 64U) + 1U) /* EOF */ ); if (*offset != 0U) { if (outBufSize < 64U) { /* 64 should be safe: enough a single byte data in 1of256 */ return ERR_NOMEM; } } else { if (outBufSize < 65U) { /* At beginning of a frame we need at least 65 bytes to start: enough for sof + 1byte data in 1of256 */ return ERR_NOMEM; } } } if (length == 0U) { *subbit_total_length = 1; } if ((length != 0U) && (0U == *offset) && sendFlags && !picopassMode) { /* set high datarate flag */ buffer[0] |= (uint8_t)ISO15693_REQ_FLAG_HIGH_DATARATE; /* clear sub-carrier flag - we only support single sub-carrier */ buffer[0] = (uint8_t)(buffer[0] & ~ISO15693_REQ_FLAG_TWO_SUBCARRIERS); /* MISRA 10.3 */ } outputBuf = outbuf; /* MISRA 17.8: Use intermediate variable */ outputBufSize = outBufSize; /* MISRA 17.8: Use intermediate variable */ /* Send SOF if at 0 offset */ if ((length != 0U) && (0U == *offset)) { *outputBuf = sof; (*actOutBufSize)++; outputBufSize--; outputBuf++; } while ((*offset < length) && (err == ERR_NONE)) { uint16_t filled_size; /* send data */ err = txFunc(buffer[*offset], outputBuf, outputBufSize, &filled_size); (*actOutBufSize) += filled_size; outputBuf = &outputBuf[filled_size]; /* MISRA 18.4: Avoid pointer arithmetic */ outputBufSize -= filled_size; if (err == ERR_NONE) { (*offset)++; } } if (err != ERR_NONE) { return ERR_AGAIN; } while ((err == ERR_NONE) && sendCrc && (*offset < (length + 2U))) { uint16_t filled_size; if (0U==crc) { crc = rfalCrcCalculateCcitt( (uint16_t) ((picopassMode) ? 0xE012U : 0xFFFFU), /* In PicoPass Mode a different Preset Value is used */ ((picopassMode) ? (buffer + 1U) : buffer), /* CMD byte is not taken into account in PicoPass mode */ ((picopassMode) ? (length - 1U) : length)); /* CMD byte is not taken into account in PicoPass mode */ crc = (uint16_t)((picopassMode) ? crc : ~crc); } /* send crc */ transbuf[0] = (uint8_t)(crc & 0xffU); transbuf[1] = (uint8_t)((crc >> 8) & 0xffU); err = txFunc(transbuf[*offset - length], outputBuf, outputBufSize, &filled_size); (*actOutBufSize) += filled_size; outputBuf = &outputBuf[filled_size]; /* MISRA 18.4: Avoid pointer arithmetic */ outputBufSize -= filled_size; if (err == ERR_NONE) { (*offset)++; } } if (err != ERR_NONE) { return ERR_AGAIN; } if ((!sendCrc && (*offset == length)) || (sendCrc && (*offset == (length + 2U)))) { *outputBuf = eof; (*actOutBufSize)++; outputBufSize--; outputBuf++; } else { return ERR_AGAIN; } return err; } ReturnCode iso15693VICCDecode(const uint8_t *inBuf, uint16_t inBufLen, uint8_t* outBuf, uint16_t outBufLen, uint16_t* outBufPos, uint16_t* bitsBeforeCol, uint16_t ignoreBits, bool picopassMode ) { ReturnCode err = ERR_NONE; uint16_t crc; uint16_t mp; /* Current bit position in manchester bit inBuf*/ uint16_t bp; /* Current bit position in outBuf */ *bitsBeforeCol = 0; *outBufPos = 0; /* first check for valid SOF. Since it starts with 3 unmodulated pulses it is 0x17. */ if ((inBuf[0] & 0x1fU) != 0x17U) { ISO_15693_DEBUG("0x%x\n", iso15693PhyBitBuffer[0]); return ERR_FRAMING; } ISO_15693_DEBUG("SOF\n"); if (outBufLen == 0U) { return ERR_NONE; } mp = 5; /* 5 bits were SOF, now manchester starts: 2 bits per payload bit */ bp = 0; ST_MEMSET(outBuf,0,outBufLen); if (inBufLen == 0U) { return ERR_CRC; } for ( ; mp < ((inBufLen * 8U) - 2U); mp+=2U ) { bool isEOF = false; uint8_t man; man = (inBuf[mp/8U] >> (mp%8U)) & 0x1U; man |= ((inBuf[(mp+1U)/8U] >> ((mp+1U)%8U)) & 0x1U) << 1; if (1U == man) { bp++; } if (2U == man) { outBuf[bp/8U] = (uint8_t)(outBuf[bp/8U] | (1U <<(bp%8U))); /* MISRA 10.3 */ bp++; } if ((bp%8U) == 0U) { /* Check for EOF */ ISO_15693_DEBUG("ceof %hhx %hhx\n", inBuf[mp/8U], inBuf[mp/8+1]); if ( ((inBuf[mp/8U] & 0xe0U) == 0xa0U) &&(inBuf[(mp/8U)+1U] == 0x03U)) { /* Now we know that it was 10111000 = EOF */ ISO_15693_DEBUG("EOF\n"); isEOF = true; } } if ( ((0U == man) || (3U == man)) && !isEOF ) { if (bp >= ignoreBits) { err = ERR_RF_COLLISION; } else { /* ignored collision: leave as 0 */ bp++; } } if ( (bp >= (outBufLen * 8U)) || (err == ERR_RF_COLLISION) || isEOF ) { /* Don't write beyond the end */ break; } } *outBufPos = (bp / 8U); *bitsBeforeCol = bp; if (err != ERR_NONE) { return err; } if ((bp%8U) != 0U) { return ERR_CRC; } if (*outBufPos > 2U) { /* finally, check crc */ ISO_15693_DEBUG("Calculate CRC, val: 0x%x, outBufLen: ", *outBuf); ISO_15693_DEBUG("0x%x ", *outBufPos - 2); crc = rfalCrcCalculateCcitt(((picopassMode) ? 0xE012U : 0xFFFFU), outBuf, *outBufPos - 2U); crc = (uint16_t)((picopassMode) ? crc : ~crc); if (((crc & 0xffU) == outBuf[*outBufPos-2U]) && (((crc >> 8U) & 0xffU) == outBuf[*outBufPos-1U])) { err = ERR_NONE; ISO_15693_DEBUG("OK\n"); } else { ISO_15693_DEBUG("error! Expected: 0x%x, got ", crc); ISO_15693_DEBUG("0x%hhx 0x%hhx\n", outBuf[*outBufPos-2], outBuf[*outBufPos-1]); err = ERR_CRC; } } else { err = ERR_CRC; } return err; } /* ****************************************************************************** * LOCAL FUNCTIONS ****************************************************************************** */ /*! ***************************************************************************** * \brief Perform 1 of 4 coding and send coded data * * This function takes \a length bytes from \a buffer, perform 1 of 4 coding * (see ISO15693-2 specification) and sends the data using stream mode. * * \param[in] sendSof : send SOF prior to data. * \param[in] buffer : data to send. * \param[in] length : number of bytes to send. * * \return ERR_IO : Error during communication. * \return ERR_NONE : No error. * ***************************************************************************** */ static ReturnCode iso15693PhyVCDCode1Of4(const uint8_t data, uint8_t* outbuffer, uint16_t maxOutBufLen, uint16_t* outBufLen) { uint8_t tmp; ReturnCode err = ERR_NONE; uint16_t a; uint8_t* outbuf = outbuffer; *outBufLen = 0; if (maxOutBufLen < 4U) { return ERR_NOMEM; } tmp = data; for (a = 0; a < 4U; a++) { switch (tmp & 0x3U) { case 0: *outbuf = ISO15693_DAT_00_1_4; break; case 1: *outbuf = ISO15693_DAT_01_1_4; break; case 2: *outbuf = ISO15693_DAT_10_1_4; break; case 3: *outbuf = ISO15693_DAT_11_1_4; break; default: /* MISRA 16.4: mandatory default statement */ break; } outbuf++; (*outBufLen)++; tmp >>= 2; } return err; } /*! ***************************************************************************** * \brief Perform 1 of 256 coding and send coded data * * This function takes \a length bytes from \a buffer, perform 1 of 256 coding * (see ISO15693-2 specification) and sends the data using stream mode. * \note This function sends SOF prior to the data. * * \param[in] sendSof : send SOF prior to data. * \param[in] buffer : data to send. * \param[in] length : number of bytes to send. * * \return ERR_IO : Error during communication. * \return ERR_NONE : No error. * ***************************************************************************** */ static ReturnCode iso15693PhyVCDCode1Of256(const uint8_t data, uint8_t* outbuffer, uint16_t maxOutBufLen, uint16_t* outBufLen) { uint8_t tmp; ReturnCode err = ERR_NONE; uint16_t a; uint8_t* outbuf = outbuffer; *outBufLen = 0; if (maxOutBufLen < 64U) { return ERR_NOMEM; } tmp = data; for (a = 0; a < 64U; a++) { switch (tmp) { case 0: *outbuf = ISO15693_DAT_SLOT0_1_256; break; case 1: *outbuf = ISO15693_DAT_SLOT1_1_256; break; case 2: *outbuf = ISO15693_DAT_SLOT2_1_256; break; case 3: *outbuf = ISO15693_DAT_SLOT3_1_256; break; default: *outbuf = 0; break; } outbuf++; (*outBufLen)++; tmp -= 4U; } return err; } #endif /* RFAL_FEATURE_NFCV */