28 #endif // HAVE_CONFIG_H
39 #include "../mirror-subr.h"
42 # include "../../contrib/windows.h"
45 #include <sys/param.h>
48 const byte_t pncmd_get_firmware_version[2] = { 0xD4, 0x02 };
49 const byte_t pncmd_get_general_status[2] = { 0xD4, 0x04 };
50 const byte_t pncmd_get_register[4] = { 0xD4, 0x06 };
51 const byte_t pncmd_set_register[5] = { 0xD4, 0x08 };
52 const byte_t pncmd_set_parameters[3] = { 0xD4, 0x12 };
53 const byte_t pncmd_rf_configure[14] = { 0xD4, 0x32 };
56 const byte_t pncmd_initiator_list_passive[264] = { 0xD4, 0x4A };
57 const byte_t pncmd_initiator_jump_for_dep[68] = { 0xD4, 0x56 };
58 const byte_t pncmd_initiator_select[3] = { 0xD4, 0x54 };
59 const byte_t pncmd_initiator_deselect[3] = { 0xD4, 0x44, 0x00 };
60 const byte_t pncmd_initiator_release[3] = { 0xD4, 0x52, 0x00 };
61 const byte_t pncmd_initiator_set_baud_rate[5] = { 0xD4, 0x4E };
62 const byte_t pncmd_initiator_exchange_data[265] = { 0xD4, 0x40 };
63 const byte_t pncmd_initiator_exchange_raw_data[266] = { 0xD4, 0x42 };
64 const byte_t pncmd_initiator_auto_poll[5] = { 0xD4, 0x60 };
67 const byte_t pncmd_target_get_data[2] = { 0xD4, 0x86 };
68 const byte_t pncmd_target_set_data[264] = { 0xD4, 0x8E };
69 const byte_t pncmd_target_init[2] = { 0xD4, 0x8C };
72 const byte_t pncmd_target_virtual_card[4] = { 0xD4, 0x14 };
73 const byte_t pncmd_target_get_initiator_command[2] = { 0xD4, 0x88 };
74 const byte_t pncmd_target_response_to_initiator[264] = { 0xD4, 0x90 };
75 const byte_t pncmd_target_get_status[2] = { 0xD4, 0x8A };
77 static const byte_t pn53x_ack_frame[] = { 0x00, 0x00, 0xff, 0x00, 0xff, 0x00 };
78 static const byte_t pn53x_nack_frame[] = { 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 };
79 static const byte_t pn53x_error_frame[] = { 0x00, 0x00, 0xff, 0x01, 0xff, 0x7f, 0x81, 0x00 };
96 if (!pn53x_set_reg (pnd, REG_CIU_BIT_FRAMING, SYMBOL_TX_LAST_BITS, 0x00)) {
102 if(!pn53x_SetParameters(pnd, PARAM_AUTO_ATR_RES | PARAM_AUTO_RATS)) {
106 char abtFirmwareText[18];
107 if (!pn53x_get_firmware_version (pnd, abtFirmwareText)) {
113 pcName = strdup (pnd->
acName);
114 snprintf (pnd->
acName, DEVICE_NAME_LENGTH - 1,
"%s - %s", pcName, abtFirmwareText);
120 pn53x_check_ack_frame_callback (
nfc_device_t * pnd,
const byte_t * pbtRxFrame,
const size_t szRxFrameLen)
122 if (szRxFrameLen >=
sizeof (pn53x_ack_frame)) {
123 if (0 == memcmp (pbtRxFrame, pn53x_ack_frame,
sizeof (pn53x_ack_frame))) {
126 }
else if (0 == memcmp (pbtRxFrame, pn53x_nack_frame,
sizeof (pn53x_nack_frame))) {
127 DBG (
"%s",
"PN53x NACKed");
135 ERR (
"%s",
"Unexpected PN53x reply!");
144 pn53x_check_error_frame_callback (
nfc_device_t * pnd,
const byte_t * pbtRxFrame,
const size_t szRxFrameLen)
146 if (szRxFrameLen >=
sizeof (pn53x_error_frame)) {
147 if (0 == memcmp (pbtRxFrame, pn53x_error_frame,
sizeof (pn53x_error_frame))) {
148 DBG (
"%s",
"PN53x sent an error frame");
157 #define PN53x_REPLY_FRAME_MAX_LEN (PN53x_EXTENDED_FRAME_MAX_LEN + PN53x_EXTENDED_FRAME_OVERHEAD + sizeof(pn53x_ack_frame))
159 pn53x_transceive (
nfc_device_t * pnd,
const byte_t * pbtTx,
const size_t szTx, byte_t * pbtRx,
size_t * pszRx)
161 byte_t abtRx[PN53x_REPLY_FRAME_MAX_LEN];
162 size_t szRx = PN53x_EXTENDED_FRAME_MAX_LEN;
165 if (!pszRx || !pbtRx) {
171 if(*pszRx > PN53x_EXTENDED_FRAME_MAX_LEN) {
172 DBG(
"Expected reply bytes count (*pszRx=%zu) is greater than MAX (PN53x_EXTENDED_FRAME_MAX_LEN=%d)", *pszRx, PN53x_EXTENDED_FRAME_MAX_LEN );
173 *pszRx=MIN(*pszRx, PN53x_EXTENDED_FRAME_MAX_LEN);
178 *pszRx +=
sizeof(pn53x_ack_frame) + PN53x_EXTENDED_FRAME_OVERHEAD;
207 if (pnd->
nc == NC_PN533) {
208 if ((pbtTx[1] == 0x06)
209 || (pbtTx[1] == 0x08)) {
218 pn53x_get_reg (
nfc_device_t * pnd, uint16_t ui16Reg, uint8_t * ui8Value)
220 byte_t abtCmd[
sizeof (pncmd_get_register)];
221 memcpy (abtCmd, pncmd_get_register,
sizeof (pncmd_get_register));
223 abtCmd[2] = ui16Reg >> 8;
224 abtCmd[3] = ui16Reg & 0xff;
226 byte_t abtRegValue[2];
227 size_t szValueLen = 3 + PN53x_NORMAL_FRAME_OVERHEAD;
228 if (pn53x_transceive (pnd, abtCmd,
sizeof (pncmd_get_register), abtRegValue, &szValueLen)) {
229 if (pnd->
nc == NC_PN533) {
231 if (abtRegValue[0] == 0) {
232 *ui8Value = abtRegValue[1];
237 *ui8Value = abtRegValue[0];
245 pn53x_set_reg (
nfc_device_t * pnd, uint16_t ui16Reg, uint8_t ui8SymbolMask, uint8_t ui8Value)
248 byte_t abtCmd[
sizeof (pncmd_set_register)];
249 memcpy (abtCmd, pncmd_set_register,
sizeof (pncmd_set_register));
251 abtCmd[2] = ui16Reg >> 8;
252 abtCmd[3] = ui16Reg & 0xff;
253 if (ui8SymbolMask != 0xff) {
254 if (!pn53x_get_reg (pnd, ui16Reg, &ui8Current))
256 abtCmd[4] = ui8Value | (ui8Current & (~ui8SymbolMask));
257 return (abtCmd[4] != ui8Current) ? pn53x_transceive (pnd, abtCmd,
sizeof (pncmd_set_register), NULL, NULL) : true;
259 abtCmd[4] = ui8Value;
260 return pn53x_transceive (pnd, abtCmd,
sizeof (pncmd_set_register), NULL, NULL);
265 pn53x_set_parameter (
nfc_device_t * pnd,
const uint8_t ui8Parameter,
const bool bEnable)
269 return pn53x_SetParameters(pnd, ui8Value);
275 pn53x_SetParameters (
nfc_device_t * pnd,
const uint8_t ui8Value)
277 byte_t abtCmd[
sizeof (pncmd_set_parameters)];
278 memcpy (abtCmd, pncmd_set_parameters,
sizeof (pncmd_set_parameters));
280 abtCmd[2] = ui8Value;
281 if(!pn53x_transceive (pnd, abtCmd,
sizeof (pncmd_set_parameters), NULL, NULL)) {
290 pn53x_set_tx_bits (
nfc_device_t * pnd,
const uint8_t ui8Bits)
295 if (!pn53x_set_reg (pnd, REG_CIU_BIT_FRAMING, SYMBOL_TX_LAST_BITS, ui8Bits))
305 pn53x_wrap_frame (
const byte_t * pbtTx,
const size_t szTxBits,
const byte_t * pbtTxPar,
306 byte_t * pbtFrame,
size_t * pszFrameBits)
311 uint32_t uiDataPos = 0;
312 size_t szBitsLeft = szTxBits;
319 if (szBitsLeft < 9) {
321 *pszFrameBits = szTxBits;
325 *pszFrameBits = szTxBits + (szTxBits / 8);
336 for (uiBitPos = 0; uiBitPos < 8; uiBitPos++) {
338 btData = mirror (pbtTx[uiDataPos]);
339 btFrame |= (btData >> uiBitPos);
341 *pbtFrame = mirror (btFrame);
343 btFrame = (btData << (8 - uiBitPos));
344 btFrame |= ((pbtTxPar[uiDataPos] & 0x01) << (7 - uiBitPos));
347 *pbtFrame = mirror (btFrame);
361 pn53x_unwrap_frame (
const byte_t * pbtFrame,
const size_t szFrameBits, byte_t * pbtRx,
size_t * pszRxBits,
367 uint32_t uiDataPos = 0;
368 byte_t *pbtFramePos = (byte_t *) pbtFrame;
369 size_t szBitsLeft = szFrameBits;
376 if (szBitsLeft < 9) {
378 *pszRxBits = szFrameBits;
382 *pszRxBits = szFrameBits - (szFrameBits / 9);
387 for (uiBitPos = 0; uiBitPos < 8; uiBitPos++) {
388 btFrame = mirror (pbtFramePos[uiDataPos]);
389 btData = (btFrame << uiBitPos);
390 btFrame = mirror (pbtFramePos[uiDataPos + 1]);
391 btData |= (btFrame >> (8 - uiBitPos));
392 pbtRx[uiDataPos] = mirror (btData);
393 if (pbtRxPar != NULL)
394 pbtRxPar[uiDataPos] = ((btFrame >> (7 - uiBitPos)) & 0x01);
408 pn53x_decode_target_data (
const byte_t * pbtRawData,
size_t szRawData, nfc_chip_t nc,
nfc_modulation_type_t nmt,
419 if (nc == NC_PN531) {
420 pnti->nai.abtAtqa[1] = *(pbtRawData++);
421 pnti->nai.abtAtqa[0] = *(pbtRawData++);
423 pnti->nai.abtAtqa[0] = *(pbtRawData++);
424 pnti->nai.abtAtqa[1] = *(pbtRawData++);
426 pnti->nai.btSak = *(pbtRawData++);
428 pnti->nai.szUidLen = *(pbtRawData++);
429 memcpy (pnti->nai.abtUid, pbtRawData, pnti->nai.szUidLen);
430 pbtRawData += pnti->nai.szUidLen;
433 if (szRawData > (pnti->nai.szUidLen + 5)) {
434 pnti->nai.szAtsLen = ((*(pbtRawData++)) - 1);
435 memcpy (pnti->nai.abtAts, pbtRawData, pnti->nai.szAtsLen);
437 pnti->nai.szAtsLen = 0;
442 if ((pnti->nai.szUidLen == 8) && (pnti->nai.abtUid[0] == 0x88)) {
443 pnti->nai.szUidLen = 7;
444 memmove (pnti->nai.abtUid, pnti->nai.abtUid + 1, 7);
445 }
else if ((pnti->nai.szUidLen == 12) && (pnti->nai.abtUid[0] == 0x88) && (pnti->nai.abtUid[4] == 0x88)) {
446 pnti->nai.szUidLen = 10;
447 memmove (pnti->nai.abtUid, pnti->nai.abtUid + 1, 3);
448 memmove (pnti->nai.abtUid + 3, pnti->nai.abtUid + 5, 7);
460 memcpy (pnti->nbi.
abtPupi, pbtRawData, 4);
472 szAttribRes = *(pbtRawData++);
483 pnti->nfi.szLen = *(pbtRawData++);
484 pnti->nfi.btResCode = *(pbtRawData++);
486 memcpy (pnti->nfi.abtId, pbtRawData, 8);
489 memcpy (pnti->nfi.abtPad, pbtRawData, 8);
492 if (pnti->nfi.szLen > 18) {
493 memcpy (pnti->nfi.abtSysCode, pbtRawData, 2);
501 memcpy (pnti->nji.btSensRes, pbtRawData, 2);
503 memcpy (pnti->nji.btId, pbtRawData, 4);
513 pn53x_initiator_select_passive_target (
nfc_device_t * pnd,
515 const byte_t * pbtInitData,
const size_t szInitData,
518 size_t szTargetsData;
519 byte_t abtTargetsData[PN53x_EXTENDED_FRAME_MAX_LEN];
526 if (!pn53x_InListPassiveTarget (pnd, pm, 1, pbtInitData, szInitData, abtTargetsData, &szTargetsData))
530 if (abtTargetsData[0] == 0)
537 if (!pn53x_decode_target_data (abtTargetsData + 1, szTargetsData - 1, pnd->
nc, nm.nmt, &(pnt->nti))) {
547 const byte_t btPollNr,
const byte_t btPeriod,
550 size_t szTargetTypes = 0;
552 for (
size_t n=0; n<szModulations; n++) {
558 apttTargetTypes[szTargetTypes] = ptt;
567 return pn53x_InAutoPoll (pnd, apttTargetTypes, szTargetTypes, btPollNr, btPeriod, pntTargets, pszTargetFound);
588 const byte_t * pbtInitiatorData,
const size_t szInitiatorData,
589 byte_t * pbtTargetsData,
size_t * pszTargetsData)
592 byte_t abtCmd[
sizeof (pncmd_initiator_list_passive)];
593 memcpy (abtCmd, pncmd_initiator_list_passive,
sizeof (pncmd_initiator_list_passive));
595 abtCmd[2] = szMaxTargets;
598 switch(pmInitModulation) {
612 if(pnd->
nc == NC_PN531) {
621 if((pnd->
nc != NC_PN533) || (!(pnd->
btSupportByte & SUPPORT_ISO14443B))) {
631 abtCmd[3] = pmInitModulation;
634 if (pbtInitiatorData)
635 memcpy (abtCmd + 4, pbtInitiatorData, szInitiatorData);
638 szRx = PN53x_EXTENDED_FRAME_MAX_LEN;
639 if (pn53x_transceive (pnd, abtCmd, 4 + szInitiatorData, pbtTargetsData, &szRx)) {
640 *pszTargetsData = szRx;
648 pn53x_InDeselect (
nfc_device_t * pnd,
const uint8_t ui8Target)
650 byte_t abtCmd[
sizeof (pncmd_initiator_deselect)];
651 memcpy (abtCmd, pncmd_initiator_deselect,
sizeof (pncmd_initiator_deselect));
652 abtCmd[2] = ui8Target;
654 return (pn53x_transceive (pnd, abtCmd,
sizeof (abtCmd), NULL, NULL));
658 pn53x_InRelease (
nfc_device_t * pnd,
const uint8_t ui8Target)
660 byte_t abtCmd[
sizeof (pncmd_initiator_release)];
661 memcpy (abtCmd, pncmd_initiator_release,
sizeof (pncmd_initiator_release));
662 abtCmd[2] = ui8Target;
664 return (pn53x_transceive (pnd, abtCmd,
sizeof (abtCmd), NULL, NULL));
670 const byte_t btPollNr,
const byte_t btPeriod,
nfc_target_t * pntTargets,
size_t * pszTargetFound)
672 size_t szTxInAutoPoll,
674 byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
675 size_t szRx = PN53x_EXTENDED_FRAME_MAX_LEN;
677 byte_t *pbtTxInAutoPoll;
679 if (pnd->
nc != NC_PN532) {
685 szTxInAutoPoll = 4 + szTargetTypes;
686 pbtTxInAutoPoll = malloc (szTxInAutoPoll);
687 pbtTxInAutoPoll[0] = 0xd4;
688 pbtTxInAutoPoll[1] = 0x60;
689 pbtTxInAutoPoll[2] = btPollNr;
690 pbtTxInAutoPoll[3] = btPeriod;
691 for (n = 0; n < szTargetTypes; n++) {
692 pbtTxInAutoPoll[4 + n] = ppttTargetTypes[n];
695 szRx = PN53x_EXTENDED_FRAME_MAX_LEN;
696 res = pn53x_transceive (pnd, pbtTxInAutoPoll, szTxInAutoPoll, abtRx, &szRx);
698 if ((szRx == 0) || (res ==
false)) {
701 *pszTargetFound = abtRx[0];
702 if (*pszTargetFound) {
704 byte_t *pbt = abtRx + 1;
708 pntTargets[0].nm = pn53x_ptt_to_nm(ptt);
711 pn53x_decode_target_data (pbt, ln, pnd->
nc, pntTargets[0].nm.nmt, &(pntTargets[0].nti));
718 pntTargets[1].nm = pn53x_ptt_to_nm(ptt);
721 pn53x_decode_target_data (pbt, ln, pnd->
nc, pntTargets[1].nm.nmt, &(pntTargets[1].nti));
728 static struct sErrorMessage {
730 const char *pcErrorMsg;
731 } sErrorMessages[] = {
734 { ETIMEOUT,
"Timeout" },
735 { ECRC,
"CRC Error" },
736 { EPARITY,
"Parity Error" },
737 { EBITCOUNT,
"Erroneous Bit Count" },
738 { EFRAMING,
"Framing Error" },
739 { EBITCOLL,
"Bit-collision" },
740 { ESMALLBUF,
"Communication Buffer Too Small" },
741 { EBUFOVF,
"Buffer Overflow" },
742 { ERFTIMEOUT,
"RF Timeout" },
743 { ERFPROTO,
"RF Protocol Error" },
744 { EOVHEAT,
"Chip Overheating" },
745 { EINBUFOVF,
"Internal Buffer overflow."},
746 { EINVPARAM,
"Invalid Parameter"},
748 { EDEPUNKCMD,
"Unknown DEP Command" },
750 { EMFAUTH,
"Mifare Authentication Error" },
752 { EINVRXFRAM,
"Invalid Received Frame" },
753 { ENSECNOTSUPP,
"NFC Secure not supported" },
754 { EBCC,
"Wrong UID Check Byte (BCC)" },
755 { EDEPINVSTATE,
"Invalid DEP State" },
756 { EOPNOTALL,
"Operation Not Allowed" },
757 { ECMD,
"Command Not Acceptable" },
758 { ETGREL,
"Target Released" },
761 { ECID,
"Card ID Mismatch" },
762 { ECDISCARDED,
"Card Discarded" },
763 { ENFCID3,
"NFCID3 Mismatch" },
764 { EOVCURRENT,
"Over Current" },
765 { ENAD,
"NAD Missing in DEP Frame" },
767 { ETGUIDNOTSUP,
"Target UID not supported" },
769 { DENACK,
"Received NACK" },
770 { DEACKMISMATCH,
"Expected ACK/NACK" },
771 { DEISERRFRAME,
"Received an error frame" },
775 { DEINVAL,
"Invalid argument" },
776 { DEIO,
"Input/output error" },
777 { DETIMEOUT,
"Operation timed-out" },
778 { DENOTSUP,
"Operation not supported" }
784 const char *pcRes =
"Unknown error";
787 for (i = 0; i < (
sizeof (sErrorMessages) /
sizeof (
struct sErrorMessage)); i++) {
788 if (sErrorMessages[i].iErrorCode == pnd->
iLastError) {
789 pcRes = sErrorMessages[i].pcErrorMsg;
798 pn53x_get_firmware_version (
nfc_device_t * pnd,
char abtFirmwareText[18])
801 size_t szFwLen =
sizeof (abtFw);
802 if (!pn53x_transceive (pnd, pncmd_get_firmware_version, 2, abtFw, &szFwLen)) {
810 snprintf (abtFirmwareText, 18,
"PN531 v%d.%d", abtFw[0], abtFw[1]);
814 snprintf (abtFirmwareText, 18,
"PN532 v%d.%d (0x%02x)", abtFw[1], abtFw[2], abtFw[3]);
818 snprintf (abtFirmwareText, 18,
"PN533 v%d.%d (0x%02x)", abtFw[1], abtFw[2], abtFw[3]);
823 abtFirmwareText[17] =
'\0';
831 byte_t abtCmd[
sizeof (pncmd_rf_configure)];
833 memcpy (abtCmd, pncmd_rf_configure,
sizeof (pncmd_rf_configure));
843 btValue = (bEnable) ? 0x80 : 0x00;
844 if (!pn53x_set_reg (pnd, REG_CIU_TX_MODE, SYMBOL_TX_CRC_ENABLE, btValue))
846 if (!pn53x_set_reg (pnd, REG_CIU_RX_MODE, SYMBOL_RX_CRC_ENABLE, btValue))
853 btValue = (bEnable) ? 0x00 : SYMBOL_PARITY_DISABLE;
854 if (!pn53x_set_reg (pnd, REG_CIU_MANUAL_RCV, SYMBOL_PARITY_DISABLE, btValue))
864 abtCmd[2] = RFCI_FIELD;
865 abtCmd[3] = (bEnable) ? 1 : 0;
866 if (!pn53x_transceive (pnd, abtCmd, 4, NULL, NULL))
871 btValue = (bEnable) ? SYMBOL_MF_CRYPTO1_ON : 0x00;
872 if (!pn53x_set_reg (pnd, REG_CIU_STATUS2, SYMBOL_MF_CRYPTO1_ON, btValue))
882 abtCmd[2] = RFCI_RETRY_SELECT;
883 abtCmd[3] = (bEnable) ? 0xff : 0x00;
884 abtCmd[4] = (bEnable) ? 0xff : 0x00;
885 abtCmd[5] = (bEnable) ? 0xff : 0x00;
886 if (!pn53x_transceive (pnd, abtCmd, 6, NULL, NULL))
891 btValue = (bEnable) ? SYMBOL_RX_NO_ERROR : 0x00;
892 if (!pn53x_set_reg (pnd, REG_CIU_RX_MODE, SYMBOL_RX_NO_ERROR, btValue))
897 btValue = (bEnable) ? SYMBOL_RX_MULTIPLE : 0x00;
898 if (!pn53x_set_reg (pnd, REG_CIU_RX_MODE, SYMBOL_RX_MULTIPLE, btValue))
906 return pn53x_set_parameter(pnd, PARAM_AUTO_RATS, bEnable);
915 if (!pn53x_set_reg (pnd, REG_CIU_TX_MODE, SYMBOL_TX_FRAMING, 0x00)) {
918 if (!pn53x_set_reg (pnd, REG_CIU_RX_MODE, SYMBOL_RX_FRAMING, 0x00)) {
935 const byte_t abtPassiveInitiatorData[5] = { 0x00, 0xff, 0xff, 0x00, 0x00 };
936 const byte_t * pbtPassiveInitiatorData = NULL;
942 pbtPassiveInitiatorData = abtPassiveInitiatorData;
951 return pn53x_InJumpForDEP (pnd, ndm, nbr, pbtPassiveInitiatorData, pndiInitiator->
abtNFCID3, pndiInitiator->
abtGB, pndiInitiator->szGB, pnt);
953 return pn53x_InJumpForDEP (pnd, ndm, nbr, pbtPassiveInitiatorData, NULL, NULL, 0, pnt);
971 const byte_t * pbtPassiveInitiatorData,
972 const byte_t * pbtNFCID3i,
973 const byte_t * pbtGBi,
const size_t szGBi,
976 byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
979 byte_t abtCmd[
sizeof (pncmd_initiator_jump_for_dep)];
981 memcpy (abtCmd, pncmd_initiator_jump_for_dep,
sizeof (pncmd_initiator_jump_for_dep));
984 abtCmd[2] = (ndm == NDM_ACTIVE) ? 0x01 : 0x00;
1004 if (pbtPassiveInitiatorData && (ndm == NDM_PASSIVE)) {
1008 memcpy (abtCmd + offset, pbtPassiveInitiatorData, 4);
1014 memcpy (abtCmd + offset, pbtPassiveInitiatorData, 5);
1028 memcpy (abtCmd + offset, pbtNFCID3i, 10);
1032 if (szGBi && pbtGBi) {
1034 memcpy (abtCmd + offset, pbtGBi, szGBi);
1038 if (!pn53x_transceive (pnd, abtCmd, offset, abtRx, &szRx))
1047 pnt->nm.nmt = NMT_DEP;
1049 memcpy (pnt->nti.ndi.
abtNFCID3, abtRx + 2, 10);
1050 pnt->nti.ndi.
btDID = abtRx[12];
1051 pnt->nti.ndi.
btBS = abtRx[13];
1052 pnt->nti.ndi.
btBR = abtRx[14];
1053 pnt->nti.ndi.
btTO = abtRx[15];
1054 pnt->nti.ndi.
btPP = abtRx[16];
1056 pnt->nti.ndi.szGB = szRx - 17;
1057 memcpy (pnt->nti.ndi.
abtGB, abtRx + 17, pnt->nti.ndi.szGB);
1059 pnt->nti.ndi.szGB = 0;
1066 pn53x_initiator_transceive_bits (
nfc_device_t * pnd,
const byte_t * pbtTx,
const size_t szTxBits,
1067 const byte_t * pbtTxPar, byte_t * pbtRx,
size_t * pszRxBits, byte_t * pbtRxPar)
1069 byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
1070 size_t szRx = PN53x_EXTENDED_FRAME_MAX_LEN;
1071 size_t szFrameBits = 0;
1072 size_t szFrameBytes = 0;
1074 uint8_t ui8Bits = 0;
1075 byte_t abtCmd[
sizeof (pncmd_initiator_exchange_raw_data)];
1077 memcpy (abtCmd, pncmd_initiator_exchange_raw_data,
sizeof (pncmd_initiator_exchange_raw_data));
1082 pn53x_wrap_frame (pbtTx, szTxBits, pbtTxPar, abtCmd + 2, &szFrameBits);
1084 szFrameBits = szTxBits;
1088 ui8Bits = szFrameBits % 8;
1091 szFrameBytes = (szFrameBits / 8) + ((ui8Bits == 0) ? 0 : 1);
1095 memcpy (abtCmd + 2, pbtTx, szFrameBytes);
1098 if (!pn53x_set_tx_bits (pnd, ui8Bits))
1103 if (!pn53x_transceive (pnd, abtCmd, szFrameBytes + 2, abtRx, &szRx))
1107 if (!pn53x_get_reg (pnd, REG_CIU_CONTROL, &ui8rcc))
1109 ui8Bits = ui8rcc & SYMBOL_RX_LAST_BITS;
1112 szFrameBits = ((szRx - 1 - ((ui8Bits == 0) ? 0 : 1)) * 8) + ui8Bits;
1118 pn53x_unwrap_frame (abtRx + 1, szFrameBits, pbtRx, pszRxBits, pbtRxPar);
1121 *pszRxBits = szFrameBits;
1123 memcpy (pbtRx, abtRx + 1, szRx - 1);
1131 pn53x_initiator_transceive_bytes (
nfc_device_t * pnd,
const byte_t * pbtTx,
const size_t szTx, byte_t * pbtRx,
1134 byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
1135 size_t szRx = PN53x_EXTENDED_FRAME_MAX_LEN;
1136 size_t szExtraTxLen;
1137 byte_t abtCmd[
sizeof (pncmd_initiator_exchange_raw_data)];
1145 memcpy (abtCmd, pncmd_initiator_exchange_data,
sizeof (pncmd_initiator_exchange_data));
1147 memcpy (abtCmd + 3, pbtTx, szTx);
1150 memcpy (abtCmd, pncmd_initiator_exchange_raw_data,
sizeof (pncmd_initiator_exchange_raw_data));
1151 memcpy (abtCmd + 2, pbtTx, szTx);
1156 if (!pn53x_set_tx_bits (pnd, 0))
1161 if (!pn53x_transceive (pnd, abtCmd, szTx + szExtraTxLen, abtRx, &szRx))
1168 memcpy (pbtRx, abtRx + 1, *pszRx);
1174 #define SAK_ISO14443_4_COMPLIANT 0x20
1179 bool bCrc = pnd->
bCrc;
1180 bool bPar = pnd->
bPar;
1183 switch (pnt->nm.nmt) {
1186 if ((pnt->nti.nai.abtUid[0] != 0x08) || (pnt->nti.nai.szUidLen != 4)) {
1190 pn53x_set_parameter(pnd, PARAM_AUTO_ATR_RES,
false);
1191 if (pnd->
nc == NC_PN532) {
1192 if ((pnt->nti.nai.btSak & SAK_ISO14443_4_COMPLIANT) && (pnd->
bAutoIso14443_4)) {
1195 pn53x_set_parameter(pnd, PARAM_14443_4_PICC,
true);
1197 pn53x_set_parameter(pnd, PARAM_14443_4_PICC,
false);
1205 pn53x_set_parameter(pnd, PARAM_AUTO_ATR_RES,
true);
1207 if (pnt->nti.ndi.
ndm == NDM_PASSIVE) {
1225 if (!pn53x_set_reg (pnd, REG_CIU_TX_AUTO, SYMBOL_INITIAL_RF_ON, 0x04))
1228 byte_t abtMifareParams[6];
1229 byte_t * pbtMifareParams = NULL;
1230 byte_t * pbtTkt = NULL;
1233 byte_t abtFeliCaParams[18];
1234 byte_t * pbtFeliCaParams = NULL;
1236 const byte_t * pbtNFCID3t = NULL;
1237 const byte_t * pbtGBt = NULL;
1240 switch(pnt->nm.nmt) {
1241 case NMT_ISO14443A: {
1243 abtMifareParams[0] = pnt->nti.nai.abtAtqa[1];
1244 abtMifareParams[1] = pnt->nti.nai.abtAtqa[0];
1247 abtMifareParams[2] = pnt->nti.nai.abtUid[1];
1248 abtMifareParams[3] = pnt->nti.nai.abtUid[2];
1249 abtMifareParams[4] = pnt->nti.nai.abtUid[3];
1251 abtMifareParams[5] = pnt->nti.nai.btSak;
1253 pbtMifareParams = abtMifareParams;
1256 pbtTkt = iso14443a_locate_historical_bytes (pnt->nti.nai.abtAts, pnt->nti.nai.szAtsLen, &szTkt);
1262 memcpy(abtFeliCaParams, pnt->nti.nfi.abtId, 8);
1264 memcpy(abtFeliCaParams+8, pnt->nti.nfi.abtPad, 8);
1266 memcpy(abtFeliCaParams+16, pnt->nti.nfi.abtSysCode, 2);
1267 pbtFeliCaParams = abtFeliCaParams;
1274 szGBt = pnt->nti.ndi.szGB;
1275 if (szGBt) pbtGBt = pnt->nti.ndi.
abtGB;
1284 bool targetActivated =
false;
1285 while (!targetActivated) {
1288 byte_t btActivatedMode;
1290 nm.nbr = NBR_UNDEFINED;
1292 if(!pn53x_TgInitAsTarget(pnd, ptm, pbtMifareParams, pbtTkt, szTkt, pbtFeliCaParams, pbtNFCID3t, pbtGBt, szGBt, pbtRx, pszRx, &btActivatedMode)) {
1297 switch(btActivatedMode & 0x70) {
1309 if (btActivatedMode & 0x04) {
1311 if ((btActivatedMode & 0x03) == 0x01) {
1317 if ((btActivatedMode & 0x03) == 0x00) {
1318 nm.nmt = NMT_ISO14443A;
1319 }
else if ((btActivatedMode & 0x03) == 0x02) {
1320 nm.nmt = NMT_FELICA;
1324 if(pnt->nm.nmt == nm.nmt) {
1325 if ((pnt->nm.nbr == NBR_UNDEFINED) || (pnt->nm.nbr == nm.nbr)) {
1326 if ((pnt->nm.nmt != NMT_DEP) || (pnt->nti.ndi.
ndm == NDM_UNDEFINED) || (pnt->nti.ndi.
ndm == ndm)) {
1327 targetActivated =
true;
1332 if (targetActivated) {
1333 pnt->nm.nbr = nm.nbr;
1334 if (pnt->nm.nmt == NMT_DEP) {
1335 pnt->nti.ndi.
ndm = ndm;
1351 const byte_t * pbtMifareParams,
1352 const byte_t * pbtTkt,
size_t szTkt,
1353 const byte_t * pbtFeliCaParams,
1354 const byte_t * pbtNFCID3t,
const byte_t * pbtGBt,
const size_t szGBt,
1355 byte_t * pbtRx,
size_t * pszRx, byte_t * pbtModeByte)
1357 byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
1359 byte_t abtCmd[39 + 47 + 48];
1360 size_t szOptionalBytes = 0;
1362 memcpy (abtCmd, pncmd_target_init,
sizeof (pncmd_target_init));
1365 memset (abtCmd +
sizeof (pncmd_target_init), 0x00,
sizeof (abtCmd) -
sizeof (pncmd_target_init));
1371 if (pbtMifareParams) {
1372 memcpy (abtCmd+3, pbtMifareParams, 6);
1375 if (pbtFeliCaParams) {
1376 memcpy (abtCmd+9, pbtFeliCaParams, 18);
1380 memcpy(abtCmd+27, pbtNFCID3t, 10);
1383 if (pnd->
nc == NC_PN531) {
1385 memcpy (abtCmd+37, pbtGBt, szGBt);
1386 szOptionalBytes = szGBt;
1389 abtCmd[37] = (byte_t)(szGBt);
1391 memcpy (abtCmd+38, pbtGBt, szGBt);
1393 szOptionalBytes = szGBt + 1;
1396 if (pnd->
nc != NC_PN531) {
1397 abtCmd[37+szOptionalBytes] = (byte_t)(szTkt);
1399 memcpy (abtCmd+38+szOptionalBytes, pbtTkt, szTkt);
1401 szOptionalBytes += szTkt + 1;
1405 szRx = PN53x_EXTENDED_FRAME_MAX_LEN;
1407 if (!pn53x_transceive (pnd, abtCmd, 37 + szOptionalBytes, abtRx, &szRx))
1413 *pbtModeByte = abtRx[0];
1419 memcpy (pbtRx, abtRx + 1, *pszRx);
1425 pn53x_target_receive_bits (
nfc_device_t * pnd, byte_t * pbtRx,
size_t * pszRxBits, byte_t * pbtRxPar)
1427 byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
1434 if (!pn53x_transceive (pnd, pncmd_target_get_initiator_command, 2, abtRx, &szRx))
1438 if (!pn53x_get_reg (pnd, REG_CIU_CONTROL, &ui8rcc))
1440 ui8Bits = ui8rcc & SYMBOL_RX_LAST_BITS;
1443 szFrameBits = ((szRx - 1 - ((ui8Bits == 0) ? 0 : 1)) * 8) + ui8Bits;
1449 pn53x_unwrap_frame (abtRx + 1, szFrameBits, pbtRx, pszRxBits, pbtRxPar);
1452 *pszRxBits = szFrameBits;
1454 memcpy (pbtRx, abtRx + 1, szRx - 1);
1461 pn53x_target_receive_bytes (
nfc_device_t * pnd, byte_t * pbtRx,
size_t * pszRx)
1463 byte_t
const *pbtTx;
1464 byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
1468 pbtTx = pncmd_target_get_data;
1470 pbtTx = pncmd_target_get_initiator_command;
1474 if (!pn53x_transceive (pnd, pbtTx, 2, abtRx, &szRx))
1481 memcpy (pbtRx, abtRx + 1, *pszRx);
1488 pn53x_target_send_bits (
nfc_device_t * pnd,
const byte_t * pbtTx,
const size_t szTxBits,
const byte_t * pbtTxPar)
1490 size_t szFrameBits = 0;
1491 size_t szFrameBytes = 0;
1492 uint8_t ui8Bits = 0;
1493 byte_t abtCmd[
sizeof (pncmd_target_response_to_initiator)];
1495 memcpy (abtCmd, pncmd_target_response_to_initiator,
sizeof (pncmd_target_response_to_initiator));
1500 pn53x_wrap_frame (pbtTx, szTxBits, pbtTxPar, abtCmd + 2, &szFrameBits);
1502 szFrameBits = szTxBits;
1506 ui8Bits = szFrameBits % 8;
1509 szFrameBytes = (szFrameBits / 8) + ((ui8Bits == 0) ? 0 : 1);
1513 memcpy (abtCmd + 2, pbtTx, szFrameBytes);
1516 if (!pn53x_set_tx_bits (pnd, ui8Bits))
1520 if (!pn53x_transceive (pnd, abtCmd, szFrameBytes + 2, NULL, NULL))
1528 pn53x_target_send_bytes (
nfc_device_t * pnd,
const byte_t * pbtTx,
const size_t szTx)
1530 byte_t abtCmd[MAX (
sizeof (pncmd_target_response_to_initiator),
sizeof (pncmd_target_set_data))];
1538 memcpy (abtCmd, pncmd_target_set_data,
sizeof (pncmd_target_set_data));
1540 memcpy (abtCmd, pncmd_target_response_to_initiator,
sizeof (pncmd_target_response_to_initiator));
1544 memcpy (abtCmd + 2, pbtTx, szTx);
1547 if (!pn53x_transceive (pnd, abtCmd, szTx + 2, NULL, NULL))