534 lines
16 KiB
C
Executable File
534 lines
16 KiB
C
Executable File
|
|
/******************************************************************************
|
|
* \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 */
|