/*
* Copyright (C) 2010 NXP Semiconductors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* 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.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* \file phFriNfc_MifULFormat.c
* \brief NFC Ndef Formatting For Mifare ultralight card.
*
* Project: NFC-FRI
*
* $Date: Mon Dec 13 14:14:12 2010 $
* $Author: ing02260 $
* $Revision: 1.9 $
* $Aliases: $
*
*/
#include <phFriNfc_MifULFormat.h>
#include <phFriNfc_OvrHal.h>
/*! \ingroup grp_file_attributes
* \name NDEF Mapping
*
* File: \ref phFriNfc_MifULFormat.c
*
*/
/*@{*/
#define PHFRINFCMIFULFORMAT_FILEREVISION "$Revision: 1.9 $"
#define PHFRINFCMIFULFORMAT_FILEALIASES "$Aliases: $"
/*@}*/
#ifdef FRINFC_READONLY_NDEF
/* Mifare UL OTP block number is 3 */
#define RD_LOCK_OTP_BLOCK_NUMBER 0x02U
#define OTP_BLOCK_NUMBER 0x03U
/* READ ONLY value that shall be written in the OTP to make the card read only */
#define READ_ONLY_VALUE_IN_OTP 0x0FU
/* Mifare UL OTP block number is 3 */
#define MIFARE_UL_READ_MAX_SIZE 16U
/* 1st Lock byte value */
#define MIFARE_UL_LOCK_BYTE1_VALUE 0xF8U
/* 2nd Lock byte value */
#define MIFARE_UL_LOCK_BYTE2_VALUE 0xFFU
/* Mifare ULC dynamic lock byte address */
#define MIFARE_ULC_DYNAMIC_LOCK_BYTES_ADDR 0x28U
/* Type 2 STATIC CARD memory value in the OTP */
#define TYPE_2_STATIC_MEM_SIZE_VALUE 0x06U
/* Type 2 DYNAMIC CARD memory value in the OTP */
#define TYPE_2_DYNAMIC_MEM_SIZE_VALUE 0x12U
/* Lock byte 3 value to be ORed with the existing value */
#define MIFARE_UL_LOCK_BYTE3_VALUE 0xEEU
/* Posiiton of the memory information in the stored OTP bytes */
#define TYPE_2_MEM_SIZE_POSITION 0x02U
/* 3rd Lock byte position after reading the block number 0x28 */
#define TYPE_2_LOCK_BYTE3_POS_RD_BLK28 0x00U
#ifdef PH_NDEF_MIFARE_ULC
/* Lock control TLVs, TYPE identifier */
#define LOCK_CTRL_TYPE_IN_TLV 0x01U
/* Lock control TLVs, Length expected */
#define LOCK_CTRL_LEN_IN_TLV 0x03U
/* NDEF message TLVs, TYPE identifier */
#define NDEF_TYPE_IN_TLV 0x03U
#define MFUL_NULL_TLV 0x00U
#define THREE_BYTE_LENGTH_FIELD 0xFFU
#define TERMINATOR_TLV 0xFEU
#define MIFARE_ULC_SIZE 0xC0U
#define MFUL_NIBBLE_SIZE 0x04U
#define MFUL_NIBBLE_MASK 0x0FU
#define MFUL_BYTE_SIZE_IN_BITS 0x08U
#define MFUL_BLOCK_SIZE_IN_BYTES 0x04U
/* Initial (0 to 3 blocks) 4 blocks are ignored, i.e., 16 bytes */
#define MFUL_INITIAL_BYTES_IGNORED 0x10U
#define MFUL_CONVERT_BITS_TO_BYTES(bits_to_bytes) \
(((bits_to_bytes % MFUL_BYTE_SIZE_IN_BITS) > 0) ? \
((bits_to_bytes / MFUL_BYTE_SIZE_IN_BITS) + 1) : \
(bits_to_bytes / MFUL_BYTE_SIZE_IN_BITS))
typedef enum phFriNfc_MfUL_Parse
{
LOCK_TLV_T,
LOCK_TLV_L,
LOCK_TLV_V,
NDEF_TLV_T,
NDEF_TLV_L,
NDEF_TLV_V
}phFriNfc_MfUL_Parse_t;
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
#endif /* #ifdef FRINFC_READONLY_NDEF */
/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function calls the
* transceive function
*/
static NFCSTATUS phFriNfc_MfUL_H_Transceive(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function calls the
* read or write operation
*/
static NFCSTATUS phFriNfc_MfUL_H_WrRd(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function fills the
* send buffer for transceive function
*/
static void phFriNfc_MfUL_H_fillSendBuf(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
uint8_t BlockNo);
/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function shall process
* the read bytes
*/
static NFCSTATUS phFriNfc_MfUL_H_ProRd16Bytes(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
/*!
* \brief \copydoc page_ovr Helper function for Mifare UL. This function shall process the
* OTP bytes written
*/
static NFCSTATUS phFriNfc_MfUL_H_ProWrOTPBytes(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
#ifdef FRINFC_READONLY_NDEF
#ifdef PH_NDEF_MIFARE_ULC
static
NFCSTATUS
phFriNfc_MfUL_ParseTLVs (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
uint8_t *data_to_parse,
uint8_t size_to_parse);
static
NFCSTATUS
phFriNfc_MfUL_GetLockBytesInfo (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
static
NFCSTATUS
phFriNfc_MfUL_GetDefaultLockBytesInfo (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
static
uint8_t
phFriNfc_MfUL_GetSkipSize (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
uint8_t block_number,
uint8_t byte_number);
static
NFCSTATUS
phFriNfc_MfUL_ReadWriteLockBytes (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
static
NFCSTATUS
phFriNfc_MfUL_UpdateAndWriteLockBits (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
static
uint8_t
phFriNfc_MfUL_CalcRemainingLockBits (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
#endif /* #ifdef FRINFC_READONLY_NDEF */
static int MemCompare1 ( void *s1, void *s2, unsigned int n );
/*The function does a comparision of two strings and returns a non zero value
if two strings are unequal*/
static int MemCompare1 ( void *s1, void *s2, unsigned int n )
{
int8_t diff = 0;
int8_t *char_1 =(int8_t *)s1;
int8_t *char_2 =(int8_t *)s2;
if(NULL == s1 || NULL == s2)
{
PHDBG_CRITICAL_ERROR("NULL pointer passed to memcompare");
}
else
{
for(;((n>0)&&(diff==0));n--,char_1++,char_2++)
{
diff = *char_1 - *char_2;
}
}
return (int)diff;
}
void phFriNfc_MfUL_Reset(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
uint8_t OTPByte[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_0;
(void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByte,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
#ifdef FRINFC_READONLY_NDEF
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[0] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[1] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] = 0;
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[3] = 0;
#endif /* #ifdef FRINFC_READONLY_NDEF */
}
NFCSTATUS phFriNfc_MfUL_Format(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS Result = NFCSTATUS_SUCCESS;
uint8_t OTPByte[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_0;
(void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByte,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
/* Set the state */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RD_16BYTES;
/* Initialise current block to the lock bits block */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = PH_FRINFC_MFUL_FMT_VAL_2;
/* Start authentication */
Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
return Result;
}
#ifdef FRINFC_READONLY_NDEF
NFCSTATUS
phFriNfc_MfUL_ConvertToReadOnly (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
NdefSmtCrdFmt->AddInfo.Type2Info.DefaultLockBytesFlag = TRUE;
NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = 0;
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_RD_16BYTES;
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
return result;
}
#endif /* #ifdef FRINFC_READONLY_NDEF */
void phFriNfc_MfUL_Process(void *Context,
NFCSTATUS Status)
{
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt = (phFriNfc_sNdefSmtCrdFmt_t *)Context;
if(Status == NFCSTATUS_SUCCESS)
{
switch(NdefSmtCrdFmt->State)
{
case PH_FRINFC_MFUL_FMT_RD_16BYTES:
Status = phFriNfc_MfUL_H_ProRd16Bytes(NdefSmtCrdFmt);
break;
case PH_FRINFC_MFUL_FMT_WR_OTPBYTES:
Status = phFriNfc_MfUL_H_ProWrOTPBytes(NdefSmtCrdFmt);
break;
case PH_FRINFC_MFUL_FMT_WR_TLV:
#ifdef PH_NDEF_MIFARE_ULC
if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
{
/* Write NDEF TLV in block number 5 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
PH_FRINFC_MFUL_FMT_VAL_5;
/* Card already have the OTP bytes so write TLV */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV1;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
break;
#ifdef FRINFC_READONLY_NDEF
case PH_FRINFC_MFUL_FMT_RO_RD_16BYTES:
{
if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
{
uint8_t otp_lock_page_size = 0;
uint8_t i = 0;
otp_lock_page_size = sizeof (NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes);
(void)memcpy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes,
(void *)NdefSmtCrdFmt->SendRecvBuf,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes));
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2] = (uint8_t)
(NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[2]
| MIFARE_UL_LOCK_BYTE1_VALUE);
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes[3] = MIFARE_UL_LOCK_BYTE2_VALUE;
i = (uint8_t)(i + otp_lock_page_size);
otp_lock_page_size = sizeof (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes);
(void)memcpy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
(void *)(NdefSmtCrdFmt->SendRecvBuf + i),
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[(otp_lock_page_size - 1)] =
READ_ONLY_VALUE_IN_OTP;
switch (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION])
{
case TYPE_2_STATIC_MEM_SIZE_VALUE:
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
break;
}
#ifdef PH_NDEF_MIFARE_ULC
case TYPE_2_DYNAMIC_MEM_SIZE_VALUE:
{
NdefSmtCrdFmt->State =
PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES;
/* Start reading from block 4 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = 4;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
break;
}
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
default:
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
break;
}
}
}
else
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_RECEIVE_LENGTH);
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES:
{
switch (NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION])
{
case TYPE_2_STATIC_MEM_SIZE_VALUE:
#ifdef PH_NDEF_MIFARE_ULC
case TYPE_2_DYNAMIC_MEM_SIZE_VALUE:
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
break;
}
default:
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
break;
}
}
break;
}
#ifdef PH_NDEF_MIFARE_ULC
case PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES:
{
if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
{
Status = phFriNfc_MfUL_ParseTLVs (NdefSmtCrdFmt,
NdefSmtCrdFmt->SendRecvBuf,
(uint8_t)*NdefSmtCrdFmt->SendRecvLength);
if (!Status)
{
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
NdefSmtCrdFmt->AddInfo.Type2Info.LockBlockNumber;
Status = phFriNfc_MfUL_ReadWriteLockBytes (NdefSmtCrdFmt);
}
}
else
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_RECEIVE_LENGTH);
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES:
{
if (MIFARE_UL_READ_MAX_SIZE == *NdefSmtCrdFmt->SendRecvLength)
{
(void)memcpy ((void *)NdefSmtCrdFmt->AddInfo.Type2Info.ReadData,
(void *)NdefSmtCrdFmt->SendRecvBuf,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.ReadData));
NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = 0;
Status = phFriNfc_MfUL_UpdateAndWriteLockBits (NdefSmtCrdFmt);
}
else
{
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_RECEIVE_LENGTH);
}
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES:
{
NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex = (uint8_t)
(NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex +
MFUL_BLOCK_SIZE_IN_BYTES);
if (!phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt))
{
/* There is no lock bits to write, then write OTP bytes */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES;
Status = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
else if ((NdefSmtCrdFmt->AddInfo.Type2Info.ReadDataIndex <
MIFARE_UL_READ_MAX_SIZE)
&& (phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)))
{
/* If remaining lock bits has to be written and the data is already read */
Status = phFriNfc_MfUL_UpdateAndWriteLockBits (NdefSmtCrdFmt);
}
else
{
/* Increment current block by 4 because if a data is read then 16
bytes will be given which is 4 blocks */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock = (uint8_t)
(NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock + 4);
Status = phFriNfc_MfUL_ReadWriteLockBytes (NdefSmtCrdFmt);
}
break;
}
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
case PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES:
{
/* Do nothing */
break;
}
#endif /* #ifdef FRINFC_READONLY_NDEF */
#ifdef PH_NDEF_MIFARE_ULC
case PH_FRINFC_MFUL_FMT_WR_TLV1:
break;
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
default:
Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_INVALID_DEVICE_REQUEST);
break;
}
}
/* Status is not success then call completion routine */
if(Status != NFCSTATUS_PENDING)
{
phFriNfc_SmtCrdFmt_HCrHandler(NdefSmtCrdFmt, Status);
}
}
#ifdef FRINFC_READONLY_NDEF
#ifdef PH_NDEF_MIFARE_ULC
static
uint8_t
phFriNfc_MfUL_GetSkipSize (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
uint8_t block_number,
uint8_t byte_number)
{
uint8_t skip_size = 0;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&NdefSmtCrdFmt->AddInfo.Type2Info;
/* This check is added, because the default lock bits is always
present after the DATA AREA.
So, default lock bytes doesnt have any skip size */
if (!ps_type2_info->DefaultLockBytesFlag)
{
/* Only check for the lock control TLV */
if ((block_number == ps_type2_info->LockBlockNumber)
&& (byte_number == ps_type2_info->LockByteNumber))
{
skip_size = MFUL_CONVERT_BITS_TO_BYTES(ps_type2_info->NoOfLockBits);
}
}
return skip_size;
}
static
NFCSTATUS
phFriNfc_MfUL_GetLockBytesInfo (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&(NdefSmtCrdFmt->AddInfo.Type2Info);
uint8_t page_address = 0;
uint8_t bytes_offset = 0;
uint8_t lock_index = 0;
page_address = (uint8_t)(ps_type2_info->DynLockBytes[lock_index] >> MFUL_NIBBLE_SIZE);
bytes_offset = (uint8_t)(ps_type2_info->DynLockBytes[lock_index] & MFUL_NIBBLE_MASK);
lock_index = (lock_index + 1);
ps_type2_info->NoOfLockBits = ps_type2_info->DynLockBytes[lock_index];
lock_index = (lock_index + 1);
ps_type2_info->LockBytesPerPage =
(ps_type2_info->DynLockBytes[lock_index] & MFUL_NIBBLE_MASK);
ps_type2_info->BytesLockedPerLockBit =
(ps_type2_info->DynLockBytes[lock_index] >> MFUL_NIBBLE_SIZE);
/* Apply the formula to calculate byte address
ByteAddr = ((PageAddr * (2 ^ BytesPerPage)) + ByteOffset)
*/
ps_type2_info->LockByteNumber = (uint8_t)((page_address
* (1 << ps_type2_info->LockBytesPerPage))
+ bytes_offset);
ps_type2_info->LockBlockNumber = (uint8_t)(ps_type2_info->LockByteNumber /
MFUL_BLOCK_SIZE_IN_BYTES);
ps_type2_info->LockByteNumber = (uint8_t)(ps_type2_info->LockByteNumber %
MFUL_BLOCK_SIZE_IN_BYTES);
#if 0
if (
/* Out of bound memory check */
((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size) >
(uint16_t)(psNdefMap->TopazContainer.CCByteBuf[2] *
TOPAZ_BYTES_PER_BLOCK)) ||
/* Check the static lock and reserved areas memory blocks */
((ps_locktlv_info->ByteAddr >= TOPAZ_STATIC_LOCK_RES_START) &&
(ps_locktlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_END)) ||
(((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1) >=
TOPAZ_STATIC_LOCK_RES_START) &&
((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1) <
TOPAZ_STATIC_LOCK_RES_END))
)
{
ps_locktlv_info->ByteAddr = 0;
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
NFCSTATUS_NO_NDEF_SUPPORT);
}
else
{
ps_locktlv_info->BlkNum = (ps_locktlv_info->ByteAddr /
TOPAZ_BYTES_PER_BLOCK);
ps_locktlv_info->ByteNum = (ps_locktlv_info->ByteAddr %
TOPAZ_BYTES_PER_BLOCK);
}
#endif /* #if 0 */
return result;
}
static
uint8_t
phFriNfc_MfUL_CalcRemainingLockBits (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
uint8_t lock_bits_remaining = 0;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&(NdefSmtCrdFmt->AddInfo.Type2Info);
lock_bits_remaining = (uint8_t)(ps_type2_info->NoOfLockBits -
ps_type2_info->LockBitsWritten);
return lock_bits_remaining;
}
static
NFCSTATUS
phFriNfc_MfUL_UpdateAndWriteLockBits (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&(NdefSmtCrdFmt->AddInfo.Type2Info);
uint8_t byte_index = 0;
uint8_t no_of_bits_left_in_block = 0;
uint8_t remaining_lock_bits = 0;
uint8_t remaining_lock_bytes = 0;
/* Array of 3 is used because the lock bits with 4 bytes in a block
is handled in the function phFriNfc_MfUL_ReadWriteLockBytes
So use this function only if lock bytes doesnt use the entire block */
uint8_t lock_bytes_value[MFUL_BLOCK_SIZE_IN_BYTES] = {0};
uint8_t lock_byte_index = 0;
(void)memcpy ((void *)lock_bytes_value,
(void*)(ps_type2_info->ReadData + ps_type2_info->ReadDataIndex),
sizeof (ps_type2_info->DynLockBytes));
remaining_lock_bits = phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt);
if (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
{
/* 1st write to lock bits, so byte_index is updated */
byte_index = ps_type2_info->LockByteNumber;
}
no_of_bits_left_in_block = (uint8_t)((MFUL_BLOCK_SIZE_IN_BYTES - byte_index) *
MFUL_BYTE_SIZE_IN_BITS);
if (no_of_bits_left_in_block >= remaining_lock_bits)
{
/* Entire lock bits can be written
if block size is more than number of lock bits.
so allocate the lock bits with value 1b and
dont change the remaining bits */
if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS)
{
/* mod operation has resulted in a value, means lock bits ends in between a byte */
uint8_t mod_value = 0;
remaining_lock_bytes = ((remaining_lock_bits /
MFUL_BYTE_SIZE_IN_BITS) + 1);
/* mod_value is used to fill the only partial bits and
remaining bits shall be untouched */
mod_value = (uint8_t)(remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS);
if (remaining_lock_bits > MFUL_BYTE_SIZE_IN_BITS)
{
/* lock bits to write is greater than 8 bits */
while (lock_byte_index < (remaining_lock_bytes - 1))
{
/* Set 1b to all bits left in the block */
lock_bytes_value[byte_index] = 0xFF;
lock_byte_index = (uint8_t)(lock_byte_index + 1);
byte_index = (uint8_t)(byte_index + 1);
}
/* Last byte of the lock bits shall be filled partially,
Set only the remaining lock bits and dont change
the other bit value */
lock_bytes_value[byte_index] = 0;
lock_bytes_value[byte_index] = (uint8_t)
SET_BITS8 (lock_bytes_value[byte_index], 0,
mod_value, 1);
}
else
{
/* lock bits to write is less than 8 bits, so
there is only one byte to write.
Set only the remaining lock bits and dont change
the other bit value */
lock_bytes_value[0] = (uint8_t)SET_BITS8 (lock_bytes_value[0], 0,
mod_value, 1);
}
} /* if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS) */
else
{
/* MOD operation is 00, that means entire byte value shall be 0xFF, means
every bit shall be to 1 */
remaining_lock_bytes = (remaining_lock_bits /
MFUL_BYTE_SIZE_IN_BITS);
while (lock_byte_index < remaining_lock_bytes)
{
/* Set 1b to all bits left in the block */
lock_bytes_value[byte_index] = 0xFF;
lock_byte_index = (uint8_t)(lock_byte_index + 1);
byte_index = (uint8_t)(byte_index + 1);
}
} /* else of if (remaining_lock_bits % MFUL_BYTE_SIZE_IN_BITS) */
ps_type2_info->LockBitsWritten = (uint8_t)(ps_type2_info->LockBitsWritten +
remaining_lock_bits);
} /* if (no_of_bits_left_in_block >= remaining_lock_bits) */
else
{
/* Update till the left bits in the block and then carry
out next operation after this write */
while (lock_byte_index < (no_of_bits_left_in_block / MFUL_BYTE_SIZE_IN_BITS))
{
/* Set 1b to all bits left in the block */
lock_bytes_value[byte_index] = 0xFF;
lock_byte_index = (uint8_t)(lock_byte_index + 1);
byte_index = (uint8_t)(byte_index + 1);
}
ps_type2_info->LockBitsWritten = (uint8_t)(ps_type2_info->LockBitsWritten +
no_of_bits_left_in_block);
} /* else of if (no_of_bits_left_in_block >= remaining_lock_bits) */
/* Copy the values back to the DynLockBytes structure member */
(void)memcpy ((void*)ps_type2_info->DynLockBytes,
(void *)lock_bytes_value,
sizeof (ps_type2_info->DynLockBytes));
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES;
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
return result;
}
static
NFCSTATUS
phFriNfc_MfUL_ReadWriteLockBytes (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&(NdefSmtCrdFmt->AddInfo.Type2Info);
uint8_t write_flag = FALSE;
if (/* Lock bytes starts from the beginning of the block */
(0 == ps_type2_info->LockByteNumber)
/* To make sure this is the first read */
&& (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
/* Lock bytes are greater than or equal to the block size, i.e., 4 bytes */
&& (phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)
>= (MFUL_BLOCK_SIZE_IN_BYTES * MFUL_BYTE_SIZE_IN_BITS)))
{
/* Then directly write the lock bytes, dont waste time for read */
(void)memset ((void *)ps_type2_info->DynLockBytes, 0xFF,
sizeof (ps_type2_info->DynLockBytes));
write_flag = TRUE;
}
else if (ps_type2_info->CurrentBlock == ps_type2_info->LockBlockNumber)
{
/* Read is mandatory, First read and then update the block,
because chances are there that lock byte may start in between
the block */
}
else if (/* check if remaining bytes exceeds or same as the block size */
(phFriNfc_MfUL_CalcRemainingLockBits (NdefSmtCrdFmt)
>= (MFUL_BLOCK_SIZE_IN_BYTES * MFUL_BYTE_SIZE_IN_BITS)))
{
/* Then directly write the lock bytes, dont waste time for read */
(void)memset ((void *)ps_type2_info->DynLockBytes, 0xFF,
sizeof (ps_type2_info->DynLockBytes));
write_flag = TRUE;
}
else
{
/* Read is mandatory, First read and then update the block */
}
if (write_flag)
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES;
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
else
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES;
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
return result;
}
static
NFCSTATUS
phFriNfc_MfUL_GetDefaultLockBytesInfo (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phFriNfc_Type2_AddInfo_t *ps_type2_info =
&(NdefSmtCrdFmt->AddInfo.Type2Info);
uint16_t lock_byte_start_addr = 0;
/* The position of the dynamic lock bits starts from
the first byte after the data area */
lock_byte_start_addr = (uint16_t)(MFUL_INITIAL_BYTES_IGNORED +
(ps_type2_info->OTPBytes[TYPE_2_MEM_SIZE_POSITION] * 8));
ps_type2_info->LockBlockNumber = (uint8_t)(lock_byte_start_addr /
MFUL_BLOCK_SIZE_IN_BYTES);
ps_type2_info->LockByteNumber = (uint8_t)(lock_byte_start_addr %
MFUL_BLOCK_SIZE_IN_BYTES);
/* Default settings
NoOfLockBits = [(DataAreaSize - 48)/8] */
ps_type2_info->NoOfLockBits = (uint8_t)
(((ps_type2_info->OTPBytes[TYPE_2_MEM_SIZE_POSITION] * 8) - 48)/8);
return result;
}
static
NFCSTATUS
phFriNfc_MfUL_ParseTLVs (
phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
uint8_t *data_to_parse,
uint8_t size_to_parse)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
static uint8_t lock_mem_ndef_index = 0;
static uint8_t skip_lock_mem_size = 0;
static uint16_t card_size_remaining = 0;
static uint16_t ndef_data_size = 0;
static phFriNfc_MfUL_Parse_t parse_tlv = LOCK_TLV_T;
uint8_t parse_index = 0;
if ((0 == card_size_remaining) && (0 == parse_index))
{
/* card size is calculated only once */
card_size_remaining = (uint16_t)
(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION] * 8);
}
while ((parse_index < size_to_parse)
&& (NFCSTATUS_SUCCESS == result)
&& (NDEF_TLV_V != parse_tlv)
&& (0 != card_size_remaining))
{
if (0 == skip_lock_mem_size)
{
/* Skip the lock TLVs, so get the lock bits */
skip_lock_mem_size = phFriNfc_MfUL_GetSkipSize (NdefSmtCrdFmt,
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock,
parse_index);
}
if (0 != skip_lock_mem_size)
{
if (skip_lock_mem_size >= (size_to_parse - parse_index))
{
/* if skip size is more than the size to parse, then */
card_size_remaining = (uint16_t)(card_size_remaining -
(size_to_parse - parse_index));
skip_lock_mem_size = (uint8_t)(skip_lock_mem_size -
((size_to_parse - parse_index)));
parse_index = size_to_parse;
}
else
{
card_size_remaining = (uint16_t)(card_size_remaining -
skip_lock_mem_size);
parse_index = (uint8_t)(parse_index + skip_lock_mem_size);
skip_lock_mem_size = 0;
}
}
else
{
switch (parse_tlv)
{
case LOCK_TLV_T:
{
switch (*(data_to_parse + parse_index))
{
case MFUL_NULL_TLV:
{
/* Do nothing, parse further */
break;
}
case LOCK_CTRL_TYPE_IN_TLV:
{
parse_tlv = LOCK_TLV_L;
break;
}
case NDEF_TYPE_IN_TLV:
{
parse_tlv = NDEF_TLV_T;
/* Default lock bytes shall be taken */
NdefSmtCrdFmt->AddInfo.Type2Info.DefaultLockBytesFlag =
TRUE;
result = phFriNfc_MfUL_GetDefaultLockBytesInfo (NdefSmtCrdFmt);
break;
}
default:
{
parse_tlv = LOCK_TLV_T;
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_NO_NDEF_SUPPORT);
break;
}
}
break;
}
case LOCK_TLV_L:
{
if (LOCK_CTRL_LEN_IN_TLV == *(data_to_parse + parse_index))
{
parse_tlv = LOCK_TLV_V;
}
else
{
skip_lock_mem_size = 0;
parse_tlv = LOCK_TLV_T;
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_NO_NDEF_SUPPORT);
}
break;
}
case LOCK_TLV_V:
{
switch (lock_mem_ndef_index)
{
case 0:
case 1:
{
NdefSmtCrdFmt->AddInfo.Type2Info.DefaultLockBytesFlag =
FALSE;
NdefSmtCrdFmt->AddInfo.Type2Info.DynLockBytes[lock_mem_ndef_index] =
*(data_to_parse + parse_index);
lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
break;
}
case 2:
{
NdefSmtCrdFmt->AddInfo.Type2Info.DynLockBytes[lock_mem_ndef_index] =
*(data_to_parse + parse_index);
parse_tlv = NDEF_TLV_T;
lock_mem_ndef_index = 0;
result = phFriNfc_MfUL_GetLockBytesInfo (NdefSmtCrdFmt);
break;
}
default:
{
skip_lock_mem_size = 0;
parse_tlv = LOCK_TLV_T;
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_NO_NDEF_SUPPORT);
break;
}
}
break;
} /* switch (lock_mem_ndef_index) in case LOCK_TLV_V */
case NDEF_TLV_T:
{
switch (*(data_to_parse + parse_index))
{
case MFUL_NULL_TLV:
{
/* Do nothing, parse further */
break;
}
case NDEF_TYPE_IN_TLV:
{
parse_tlv = NDEF_TLV_L;
break;
}
default:
{
skip_lock_mem_size = 0;
parse_tlv = LOCK_TLV_T;
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_NO_NDEF_SUPPORT);
break;
}
}
break;
} /* switch (*(data_to_parse + parse_index)) in case NDEF_TLV_T */
case NDEF_TLV_L:
{
switch (lock_mem_ndef_index)
{
case 0:
{
if (THREE_BYTE_LENGTH_FIELD == *(data_to_parse + parse_index))
{
lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
}
else
{
ndef_data_size = *(data_to_parse + parse_index);
parse_tlv = NDEF_TLV_V;
lock_mem_ndef_index = 0;
}
break;
}
case 1:
{
ndef_data_size = (uint16_t)(*(data_to_parse + parse_index) << 8);
break;
}
case 2:
{
ndef_data_size = (uint16_t)(ndef_data_size |
*(data_to_parse + parse_index));
parse_tlv = NDEF_TLV_V;
lock_mem_ndef_index = 0;
break;
}
} /* switch (lock_mem_ndef_index) in case NDEF_TLV_L */
break;
}
case NDEF_TLV_V:
{
break;
}
default:
{
skip_lock_mem_size = 0;
parse_tlv = LOCK_TLV_T;
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_NO_NDEF_SUPPORT);
break;
}
} /* switch (parse_tlv) */
} /* else part of if (0 != skip_lock_mem_size) */
if (0 == card_size_remaining)
{
skip_lock_mem_size = 0;
parse_tlv = LOCK_TLV_T;
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_NO_NDEF_SUPPORT);
}
else if (NDEF_TLV_V != parse_tlv)
{
/* Increment the index */
parse_index = (uint8_t)(parse_index + 1);
/* card size is decremented as the memory area is parsed */
card_size_remaining = (uint16_t)(card_size_remaining - 1);
}
else
{
/* L field of the NDEF TLV
L field can have 1 byte or also 3 bytes
*/
uint8_t length_to_deduct = 1;
if ((NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes[TYPE_2_MEM_SIZE_POSITION]
* 8) >= THREE_BYTE_LENGTH_FIELD)
{
length_to_deduct = 3;
}
/* parse_tlv has reached the VALUE field of the NDEF TLV */
if ((card_size_remaining - length_to_deduct) < ndef_data_size)
{
result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_NO_NDEF_SUPPORT);
}
lock_mem_ndef_index = 0;
skip_lock_mem_size = 0;
card_size_remaining = 0;
}
} /* while ((parse_index < size_to_parse)
&& (NFCSTATUS_SUCCESS != result)
&& (NDEF_TLV_V != parse_tlv)
&& (0 != card_size_remaining)) */
if ((NDEF_TLV_V == parse_tlv) || (NFCSTATUS_SUCCESS != result))
{
parse_tlv = LOCK_TLV_T;
}
else
{
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES;
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
(NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock + 4);
result = phFriNfc_MfUL_H_WrRd (NdefSmtCrdFmt);
}
if (NFCSTATUS_PENDING != result)
{
lock_mem_ndef_index = 0;
skip_lock_mem_size = 0;
card_size_remaining = 0;
}
return result;
}
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
#endif /* #ifdef FRINFC_READONLY_NDEF */
static NFCSTATUS phFriNfc_MfUL_H_WrRd( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt )
{
NFCSTATUS Result = NFCSTATUS_SUCCESS;
/* Fill the send buffer */
phFriNfc_MfUL_H_fillSendBuf(NdefSmtCrdFmt,
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock);
/* Call transceive */
Result = phFriNfc_MfUL_H_Transceive (NdefSmtCrdFmt);
return Result;
}
static NFCSTATUS phFriNfc_MfUL_H_Transceive(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
{
NFCSTATUS Result = NFCSTATUS_SUCCESS;
/* set the data for additional data exchange*/
NdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
NdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.NADPresent = 0;
NdefSmtCrdFmt->psDepAdditionalInfo.NAD = 0;
/*set the completion routines for the card operations*/
NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.CompletionRoutine = phFriNfc_NdefSmtCrd_Process;
NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.Context = NdefSmtCrdFmt;
*NdefSmtCrdFmt->SendRecvLength = PH_FRINFC_SMTCRDFMT_MAX_SEND_RECV_BUF_SIZE;
/* Call the Overlapped HAL Transceive function */
Result = phFriNfc_OvrHal_Transceive( NdefSmtCrdFmt->LowerDevice,
&NdefSmtCrdFmt->SmtCrdFmtCompletionInfo,
NdefSmtCrdFmt->psRemoteDevInfo,
NdefSmtCrdFmt->Cmd,
&NdefSmtCrdFmt->psDepAdditionalInfo,
NdefSmtCrdFmt->SendRecvBuf,
NdefSmtCrdFmt->SendLength,
NdefSmtCrdFmt->SendRecvBuf,
NdefSmtCrdFmt->SendRecvLength);
return Result;
}
static void phFriNfc_MfUL_H_fillSendBuf( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
uint8_t BlockNo)
{
#ifdef PH_NDEF_MIFARE_ULC
uint8_t NDEFTLV1[4] = {0x01, 0x03, 0xA0, 0x10};
uint8_t NDEFTLV2[4] = {0x44, 0x03, 0x00, 0xFE};
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
uint8_t NDEFTLV[4] = {0x03, 0x00, 0xFE, 0x00};
/* First byte for send buffer is always the block number */
NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_0] = (uint8_t)BlockNo;
switch(NdefSmtCrdFmt->State)
{
#ifdef FRINFC_READONLY_NDEF
case PH_FRINFC_MFUL_FMT_RO_RD_16BYTES:
{
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
/* Read command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
*NdefSmtCrdFmt->SendRecvBuf = RD_LOCK_OTP_BLOCK_NUMBER;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
}
#ifdef PH_NDEF_MIFARE_ULC
case PH_FRINFC_MFUL_FMT_RO_NDEF_PARSE_RD_BYTES:
{
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
/* Read command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
*NdefSmtCrdFmt->SendRecvBuf =
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
}
case PH_FRINFC_MFUL_FMT_RO_RD_DYN_LOCK_BYTES:
{
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
/* Read command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
*NdefSmtCrdFmt->SendRecvBuf = NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_DYN_LOCK_BYTES:
{
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
/* Write command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
*NdefSmtCrdFmt->SendRecvBuf = NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock;
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.DynLockBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
}
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
case PH_FRINFC_MFUL_FMT_RO_WR_LOCK_BYTES:
{
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
/* Read command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
*NdefSmtCrdFmt->SendRecvBuf = RD_LOCK_OTP_BLOCK_NUMBER;
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.LockBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
}
case PH_FRINFC_MFUL_FMT_RO_WR_OTP_BYTES:
{
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
/* Read command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
*NdefSmtCrdFmt->SendRecvBuf = OTP_BLOCK_NUMBER;
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
}
#endif /* #ifdef FRINFC_READONLY_NDEF */
case PH_FRINFC_MFUL_FMT_RD_16BYTES:
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareRead;
#else
/* Read command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareRead;
#endif /* #ifdef PH_HAL4_ENABLE */
/* Send length for read command is always one */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_1;
break;
case PH_FRINFC_MFUL_FMT_WR_OTPBYTES:
/* Send length for read command is always Five */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
/* Write command */
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */
/* Copy the OTP bytes */
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
break;
case PH_FRINFC_MFUL_FMT_WR_TLV:
#ifndef PH_NDEF_MIFARE_ULC
default:
#endif /* #ifndef PH_NDEF_MIFARE_ULC */
/* Send length for read command is always Five */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
/* Write command */
#ifdef PH_HAL4_ENABLE
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
#else
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareCmdListMifareWrite4;
#endif /* #ifdef PH_HAL4_ENABLE */
/* Copy the NDEF TLV */
#ifdef PH_NDEF_MIFARE_ULC
if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
{
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NDEFTLV1,
PH_FRINFC_MFUL_FMT_VAL_4);
}
else if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_UL_CARD)
{
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NDEFTLV,
PH_FRINFC_MFUL_FMT_VAL_4);
}
else
{
}
#else
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NDEFTLV,
PH_FRINFC_MFUL_FMT_VAL_4);
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
break;
#ifdef PH_NDEF_MIFARE_ULC
case PH_FRINFC_MFUL_FMT_WR_TLV1:
if (NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD)
{
/* Send length for write command is always Five */
NdefSmtCrdFmt->SendLength = PH_FRINFC_MFUL_FMT_VAL_5;
/* Write command */
NdefSmtCrdFmt->Cmd.MfCmd = phHal_eMifareWrite4;
(void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_1],
NDEFTLV2,
PH_FRINFC_MFUL_FMT_VAL_4);
}
break;
default:
break;
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
}
}
static NFCSTATUS phFriNfc_MfUL_H_ProRd16Bytes( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt )
{
NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
NFCSTATUS_FORMAT_ERROR);
uint32_t memcompare = PH_FRINFC_MFUL_FMT_VAL_0;
uint8_t ZeroBuf[] = {0x00, 0x00, 0x00, 0x00};
#ifdef PH_NDEF_MIFARE_ULC
uint8_t OTPByteUL[] = PH_FRINFC_MFUL_FMT_OTP_BYTES;
uint8_t OTPByteULC[] = PH_FRINFC_MFULC_FMT_OTP_BYTES;
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
/* Check the lock bits (byte number 2 and 3 of block number 2) */
if ((NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_2] ==
PH_FRINFC_MFUL_FMT_LOCK_BITS_VAL) &&
(NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_3] ==
PH_FRINFC_MFUL_FMT_LOCK_BITS_VAL))
{
#ifdef PH_NDEF_MIFARE_ULC
if (NdefSmtCrdFmt->SendRecvBuf[8] == 0x02 &&
NdefSmtCrdFmt->SendRecvBuf[9] == 0x00)
{
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
(void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByteULC,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
}
else if (NdefSmtCrdFmt->SendRecvBuf[8] == 0xFF &&
NdefSmtCrdFmt->SendRecvBuf[9] == 0xFF)
{
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
(void)memcpy(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
OTPByteUL,
sizeof(NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes));
}
else
{
NdefSmtCrdFmt->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
}
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
memcompare = (uint32_t)
MemCompare1(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_4],
NdefSmtCrdFmt->AddInfo.Type2Info.OTPBytes,
PH_FRINFC_MFUL_FMT_VAL_4);
if (memcompare == PH_FRINFC_MFUL_FMT_VAL_0)
{
/* Write NDEF TLV in block number 4 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
PH_FRINFC_MFUL_FMT_VAL_4;
/* Card already have the OTP bytes so write TLV */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV;
}
else
{
/* IS the card new, OTP bytes = {0x00, 0x00, 0x00, 0x00} */
memcompare = (uint32_t)MemCompare1(&NdefSmtCrdFmt->SendRecvBuf[PH_FRINFC_MFUL_FMT_VAL_4],
ZeroBuf,
PH_FRINFC_MFUL_FMT_VAL_4);
/* If OTP bytes are Zero then the card is Zero */
if (memcompare == PH_FRINFC_MFUL_FMT_VAL_0)
{
/* Write OTP bytes in block number 3 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
PH_FRINFC_MFUL_FMT_VAL_3;
/* Card already have the OTP bytes so write TLV */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_OTPBYTES;
}
}
}
#ifdef PH_NDEF_MIFARE_ULC
if(
((NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_TLV) ||
(NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_OTPBYTES)) &&
((NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD) ||
(NdefSmtCrdFmt->CardType == PH_FRINFC_NDEFMAP_MIFARE_UL_CARD))
)
#else
if((NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_TLV) ||
(NdefSmtCrdFmt->State == PH_FRINFC_MFUL_FMT_WR_OTPBYTES))
#endif /* #ifdef PH_NDEF_MIFARE_ULC */
{
Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
}
return Result;
}
static NFCSTATUS phFriNfc_MfUL_H_ProWrOTPBytes( phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt )
{
NFCSTATUS Result = NFCSTATUS_SUCCESS;
/* Card already have the OTP bytes so write TLV */
NdefSmtCrdFmt->State = PH_FRINFC_MFUL_FMT_WR_TLV;
/* Write NDEF TLV in block number 4 */
NdefSmtCrdFmt->AddInfo.Type2Info.CurrentBlock =
PH_FRINFC_MFUL_FMT_VAL_4;
Result = phFriNfc_MfUL_H_WrRd(NdefSmtCrdFmt);
return Result;
}