crewID/libnfc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Factorise code.

Browse source 
Avoid redundant code in PN53x usb and uart drivers.  Since it makes sense to
report errors at the nfc_device_t level, pass it directly to
pn53x_transceive().

Programs using the libnfc MAY use pn53x_transceive() to communicate with a NFC
device, and SHALL not use anymore pnd->pdc->transceive().  Code in the library
itself SHOULD avoid calling pnd->pdc->transceive(), so such construct have been
updated accordingly.
This commit is contained in:
Romain Tartiere 2010-07-31 14:20:15 +00:00
parent 301d692e8a
commit 79aeaa6287
15 changed files with 80 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
examples/nfc-sam.c
View file

@ -45,6 +45,7 @@
#include <nfc/nfc.h>
#include <nfc/nfc-messages.h>
#include "nfc-utils.h"
#include "chips/pn53x.h"
#define MAX_FRAME_LEN 264
#define TIMEOUT 60 // secs.
@ -80,7 +81,7 @@ bool sam_connection(nfc_device_t* pnd, int mode)
break;
}
if (!pnd->pdc->transceive(pnd->nds,pncmd_sam_config,szCmd,abtRx,&szRxLen)) {
if (!pn53x_transceive(pnd,pncmd_sam_config,szCmd,abtRx,&szRxLen)) {
ERR("%s %d", "Unable to execute SAMConfiguration command with mode byte:", mode);
return false;
}

6
examples/pn53x-diagnose.c
View file

@ -78,19 +78,19 @@ int main(int argc, const char* argv[])
printf("NFC device [%s] connected.\n",pnd->acName);
result = pnd->pdc->transceive(pnd->nds,pncmd_diagnose_communication_line_test,sizeof(pncmd_diagnose_communication_line_test),abtRx,&szRxLen);
result = pn53x_transceive(pnd,pncmd_diagnose_communication_line_test,sizeof(pncmd_diagnose_communication_line_test),abtRx,&szRxLen);
if ( result ) {
result = (memcmp(pncmd_diagnose_communication_line_test+2, abtRx, sizeof(pncmd_diagnose_communication_line_test)-2 ) == 0);
}
printf(" Communication line test: %s\n", result ? "OK" : "Failed");
result = pnd->pdc->transceive(pnd->nds,pncmd_diagnose_rom_test,sizeof(pncmd_diagnose_rom_test),abtRx,&szRxLen);
result = pn53x_transceive(pnd,pncmd_diagnose_rom_test,sizeof(pncmd_diagnose_rom_test),abtRx,&szRxLen);
if ( result ) {
result = ((szRxLen == 1) && (abtRx[0] == 0x00));
}
printf(" ROM test: %s\n", result ? "OK" : "Failed");
result = pnd->pdc->transceive(pnd->nds,pncmd_diagnose_ram_test,sizeof(pncmd_diagnose_ram_test),abtRx,&szRxLen);
result = pn53x_transceive(pnd,pncmd_diagnose_ram_test,sizeof(pncmd_diagnose_ram_test),abtRx,&szRxLen);
if ( result ) {
result = ((szRxLen == 1) && (abtRx[0] == 0x00));
}

2
include/nfc/nfc-types.h
View file

@ -118,7 +118,7 @@ struct driver_callbacks {
/** Connect callback */
nfc_device_t* (*connect)(const nfc_device_desc_t* pndd);
/** Transceive callback */
bool (*transceive)(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
bool (*transceive)(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
/** Disconnect callback */
void (*disconnect)(nfc_device_t* pnd);
};

4
include/nfc/nfc.h
View file

@ -60,8 +60,8 @@ NFC_EXPORT void nfc_disconnect(nfc_device_t* pnd);
NFC_EXPORT bool nfc_configure(nfc_device_t* pnd, const nfc_device_option_t ndo, const bool bEnable);
/* NFC initiator: act as "reader" */
NFC_EXPORT bool nfc_initiator_init(const nfc_device_t* pnd);
NFC_EXPORT bool nfc_initiator_select_passive_target(const nfc_device_t* pnd, const nfc_modulation_t nmInitModulation, const byte_t* pbtInitData, const size_t szInitDataLen, nfc_target_info_t* pti);
NFC_EXPORT bool nfc_initiator_init(nfc_device_t* pnd);
NFC_EXPORT bool nfc_initiator_select_passive_target(nfc_device_t* pnd, const nfc_modulation_t nmInitModulation, const byte_t* pbtInitData, const size_t szInitDataLen, nfc_target_info_t* pti);
NFC_EXPORT bool nfc_initiator_list_passive_targets(nfc_device_t* pnd, const nfc_modulation_t nmInitModulation, nfc_target_info_t anti[], const size_t szTargets, size_t *pszTargetFound );
NFC_EXPORT bool nfc_initiator_poll_targets(nfc_device_t* pnd, const nfc_target_type_t* pnttTargetTypes, const size_t szTargetTypes, const byte_t btPollNr, const byte_t btPeriod, nfc_target_t* pntTargets, size_t* pszTargetFound);
NFC_EXPORT bool nfc_initiator_select_dep_target(nfc_device_t* pnd, const nfc_modulation_t nmInitModulation, const byte_t* pbtPidData, const size_t szPidDataLen, const byte_t* pbtNFCID3i, const size_t szNFCID3iDataLen, const byte_t *pbtGbData, const size_t szGbDataLen, nfc_target_info_t* pti);

54
libnfc/chips/pn53x.c
View file

@ -26,8 +26,12 @@
#include "config.h"
#endif // HAVE_CONFIG_H
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// FIXME: WTF are doing debug macros in this file?
#include <nfc/nfc-messages.h>
#include "pn53x.h"
#include "../mirror-subr.h"
@ -60,6 +64,30 @@ const byte_t pncmd_target_receive [ 2] = { 0xD4,0x88 };
const byte_t pncmd_target_send [264] = { 0xD4,0x90 };
const byte_t pncmd_target_get_status [ 2] = { 0xD4,0x8A };
static const byte_t pn53x_ack_frame[] = { 0x00,0x00,0xff,0x00,0xff,0x00 };
static const byte_t pn53x_nack_frame[] = { 0x00,0x00,0xff,0xff,0x00,0x00 };
bool pn53x_transceive_callback(nfc_device_t* pnd, const byte_t *pbtRxFrame, const size_t szRxFrameLen)
{
(void) pnd; // I guess we will want to set some error here at some point
if (szRxFrameLen == sizeof (pn53x_ack_frame)) {
if (0 == memcmp (pbtRxFrame, pn53x_ack_frame, sizeof (pn53x_ack_frame))) {
DBG("%s", "PN53x ACKed");
return true;
} else if (0 == memcmp (pbtRxFrame, pn53x_nack_frame, sizeof (pn53x_nack_frame))) {
DBG("%s", "PN53x NACKed");
return false;
}
}
ERR("%s", "Unexpected PN53x reply!");
#if defined(DEBUG)
// coredump so that we can have a backtrace about how this code was reached.
abort();
#endif
return false;
}
bool pn53x_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
{
byte_t abtRx[MAX_FRAME_LEN];
@ -74,7 +102,7 @@ bool pn53x_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxL
*pszRxLen = MAX_FRAME_LEN;
// Call the tranceive callback function of the current device
if (!pnd->pdc->transceive(pnd->nds,pbtTx,szTxLen,pbtRx,pszRxLen)) return false;
if (!pnd->pdc->transceive(pnd,pbtTx,szTxLen,pbtRx,pszRxLen)) return false;
switch (pbtTx[1]) {
case 0x16: // PowerDown
@ -102,7 +130,7 @@ bool pn53x_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxL
return (0 == pnd->iErrorCode);
}
byte_t pn53x_get_reg(const nfc_device_t* pnd, uint16_t ui16Reg)
byte_t pn53x_get_reg(nfc_device_t* pnd, uint16_t ui16Reg)
{
uint8_t ui8Value;
size_t szValueLen = 1;
@ -111,12 +139,11 @@ byte_t pn53x_get_reg(const nfc_device_t* pnd, uint16_t ui16Reg)
abtCmd[2] = ui16Reg >> 8;
abtCmd[3] = ui16Reg & 0xff;
// We can not use pn53x_transceive() because abtRx[0] gives no status info
pnd->pdc->transceive(pnd->nds,abtCmd,4,&ui8Value,&szValueLen);
pn53x_transceive(pnd,abtCmd,4,&ui8Value,&szValueLen);
return ui8Value;
}
bool pn53x_set_reg(const nfc_device_t* pnd, uint16_t ui16Reg, uint8_t ui8SybmolMask, uint8_t ui8Value)
bool pn53x_set_reg(nfc_device_t* pnd, uint16_t ui16Reg, uint8_t ui8SybmolMask, uint8_t ui8Value)
{
byte_t abtCmd[sizeof(pncmd_set_register)];
memcpy(abtCmd,pncmd_set_register,sizeof(pncmd_set_register));
@ -124,21 +151,19 @@ bool pn53x_set_reg(const nfc_device_t* pnd, uint16_t ui16Reg, uint8_t ui8SybmolM
abtCmd[2] = ui16Reg >> 8;
abtCmd[3] = ui16Reg & 0xff;
abtCmd[4] = ui8Value | (pn53x_get_reg(pnd,ui16Reg) & (~ui8SybmolMask));
// We can not use pn53x_transceive() because abtRx[0] gives no status info
return pnd->pdc->transceive(pnd->nds,abtCmd,5,NULL,NULL);
return pn53x_transceive(pnd,abtCmd,5,NULL,NULL);
}
bool pn53x_set_parameters(const nfc_device_t* pnd, uint8_t ui8Value)
bool pn53x_set_parameters(nfc_device_t* pnd, uint8_t ui8Value)
{
byte_t abtCmd[sizeof(pncmd_set_parameters)];
memcpy(abtCmd,pncmd_set_parameters,sizeof(pncmd_set_parameters));
abtCmd[2] = ui8Value;
// We can not use pn53x_transceive() because abtRx[0] gives no status info
return pnd->pdc->transceive(pnd->nds,abtCmd,3,NULL,NULL);
return pn53x_transceive(pnd,abtCmd,3,NULL,NULL);
}
bool pn53x_set_tx_bits(const nfc_device_t* pnd, uint8_t ui8Bits)
bool pn53x_set_tx_bits(nfc_device_t* pnd, uint8_t ui8Bits)
{
// Test if we need to update the transmission bits register setting
if (pnd->ui8TxBits != ui8Bits)
@ -307,7 +332,7 @@ pn53x_decode_target_data(const byte_t* pbtRawData, size_t szDataLen, nfc_chip_t
* @note To decode theses TargetData[n], there is @fn pn53x_decode_target_data
*/
bool
pn53x_InListPassiveTarget(const nfc_device_t* pnd,
pn53x_InListPassiveTarget(nfc_device_t* pnd,
const nfc_modulation_t nmInitModulation, const byte_t szMaxTargets,
const byte_t* pbtInitiatorData, const size_t szInitiatorDataLen,
byte_t* pbtTargetsData, size_t* pszTargetsData)
@ -324,8 +349,7 @@ pn53x_InListPassiveTarget(const nfc_device_t* pnd,
// Try to find a tag, call the tranceive callback function of the current device
size_t szRxLen = MAX_FRAME_LEN;
// We can not use pn53x_transceive() because abtRx[0] gives no status info
if(pnd->pdc->transceive(pnd->nds,abtCmd,4+szInitiatorDataLen,pbtTargetsData,&szRxLen)) {
if(pn53x_transceive(pnd,abtCmd,4+szInitiatorDataLen,pbtTargetsData,&szRxLen)) {
*pszTargetsData = szRxLen;
return true;
} else {

11
libnfc/chips/pn53x.h
View file

@ -69,16 +69,17 @@
#define RFCI_ANALOG_TYPE_B 0x0C // 3
#define RFCI_ANALOG_TYPE_14443_4 0x0D // 9
bool pn53x_transceive_callback(nfc_device_t* pnd, const byte_t *pbtRxFrame, const size_t szRxFrameLen);
bool pn53x_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
byte_t pn53x_get_reg(const nfc_device_t* pnd, uint16_t ui16Reg);
bool pn53x_set_reg(const nfc_device_t* pnd, uint16_t ui16Reg, uint8_t ui8SybmolMask, uint8_t ui8Value);
bool pn53x_set_parameters(const nfc_device_t* pnd, uint8_t ui8Value);
bool pn53x_set_tx_bits(const nfc_device_t* pnd, uint8_t ui8Bits);
byte_t pn53x_get_reg(nfc_device_t* pnd, uint16_t ui16Reg);
bool pn53x_set_reg(nfc_device_t* pnd, uint16_t ui16Reg, uint8_t ui8SybmolMask, uint8_t ui8Value);
bool pn53x_set_parameters(nfc_device_t* pnd, uint8_t ui8Value);
bool pn53x_set_tx_bits(nfc_device_t* pnd, uint8_t ui8Bits);
bool pn53x_wrap_frame(const byte_t* pbtTx, const size_t szTxBits, const byte_t* pbtTxPar, byte_t* pbtFrame, size_t* pszFrameBits);
bool pn53x_unwrap_frame(const byte_t* pbtFrame, const size_t szFrameBits, byte_t* pbtRx, size_t* pszRxBits, byte_t* pbtRxPar);
bool pn53x_decode_target_data(const byte_t* pbtRawData, size_t szDataLen, nfc_chip_t nc, nfc_target_type_t ntt, nfc_target_info_t* pnti);
bool pn53x_InListPassiveTarget(const nfc_device_t* pnd, const nfc_modulation_t nmInitModulation, const byte_t szMaxTargets, const byte_t* pbtInitiatorData, const size_t szInitiatorDataLen, byte_t* pbtTargetsData, size_t* pszTargetsData);
bool pn53x_InListPassiveTarget(nfc_device_t* pnd, const nfc_modulation_t nmInitModulation, const byte_t szMaxTargets, const byte_t* pbtInitiatorData, const size_t szInitiatorDataLen, byte_t* pbtTargetsData, size_t* pszTargetsData);
bool pn53x_InDeselect(nfc_device_t* pnd, const uint8_t ui8Target);
const char *pn53x_strerror (const nfc_device_t *pnd);

4
libnfc/drivers/acr122.c
View file

@ -259,14 +259,14 @@ void acr122_disconnect(nfc_device_t* pnd)
free(pnd);
}
bool acr122_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
bool acr122_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
{
byte_t abtRxCmd[5] = { 0xFF,0xC0,0x00,0x00 };
size_t szRxCmdLen = sizeof(abtRxCmd);
byte_t abtRxBuf[ACR122_RESPONSE_LEN];
size_t szRxBufLen;
byte_t abtTxBuf[ACR122_WRAP_LEN+ACR122_COMMAND_LEN] = { 0xFF, 0x00, 0x00, 0x00 };
acr122_spec_t* pas = (acr122_spec_t*)nds;
acr122_spec_t* pas = (acr122_spec_t*)pnd->nds;
// Make sure the command does not overflow the send buffer
if (szTxLen > ACR122_COMMAND_LEN) return false;

2
libnfc/drivers/acr122.h
View file

@ -40,7 +40,7 @@ nfc_device_t* acr122_connect(const nfc_device_desc_t* pndd);
void acr122_disconnect(nfc_device_t* pnd);
// Callback function used by libnfc to transmit commands to the PN53X chip
bool acr122_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
bool acr122_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
// Various additional features this device supports
char* acr122_firmware(const nfc_device_spec_t nds);

8
libnfc/drivers/arygon.c
View file

@ -214,7 +214,7 @@ void arygon_disconnect(nfc_device_t* pnd)
free(pnd);
}
bool arygon_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
bool arygon_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
{
byte_t abtTxBuf[BUFFER_LENGTH] = { DEV_ARYGON_PROTOCOL_TAMA, 0x00, 0x00, 0xff }; // Every packet must start with "00 00 ff"
byte_t abtRxBuf[BUFFER_LENGTH];
@ -244,12 +244,12 @@ bool arygon_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const s
#ifdef DEBUG
PRINT_HEX("TX", abtTxBuf,szTxLen+8);
#endif
if (!uart_send((serial_port)nds,abtTxBuf,szTxLen+8)) {
if (!uart_send((serial_port)pnd->nds,abtTxBuf,szTxLen+8)) {
ERR("%s", "Unable to transmit data. (TX)");
return false;
}
if (!uart_receive((serial_port)nds,abtRxBuf,&szRxBufLen)) {
if (!uart_receive((serial_port)pnd->nds,abtRxBuf,&szRxBufLen)) {
ERR("%s", "Unable to receive data. (RX)");
return false;
}
@ -279,7 +279,7 @@ bool arygon_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const s
if(szRxBufLen == 0) {
// There was no more data than ACK frame, we need to wait next frame
DBG("%s", "There was no more data than ACK frame, we need to wait next frame");
while (!uart_receive((serial_port)nds,abtRxBuf,&szRxBufLen)) {
while (!uart_receive((serial_port)pnd->nds,abtRxBuf,&szRxBufLen)) {
delay_ms(10);
}
}

2
libnfc/drivers/arygon.h
View file

@ -36,7 +36,7 @@ nfc_device_t* arygon_connect(const nfc_device_desc_t* pndd);
void arygon_disconnect(nfc_device_t* pnd);
// Callback function used by libnfc to transmit commands to the PN53X chip
bool arygon_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
bool arygon_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
#endif // ! __NFC_DRIVER_ARYGON_H__

35
libnfc/drivers/pn532_uart.c
View file

@ -29,6 +29,7 @@
#endif // HAVE_CONFIG_H
#include "../drivers.h"
#include "../chips/pn53x.h"
#include <stdio.h>
#include <string.h>
@ -197,14 +198,12 @@ void pn532_uart_disconnect(nfc_device_t* pnd)
free(pnd);
}
bool pn532_uart_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
bool pn532_uart_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
{
byte_t abtTxBuf[BUFFER_LENGTH] = { 0x00, 0x00, 0xff }; // Every packet must start with "00 00 ff"
byte_t abtRxBuf[BUFFER_LENGTH];
size_t szRxBufLen = BUFFER_LENGTH;
size_t szPos;
const byte_t pn53x_ack_frame[] = { 0x00,0x00,0xff,0x00,0xff,0x00 };
const byte_t pn53x_nack_frame[] = { 0x00,0x00,0xff,0xff,0x00,0x00 };
// Packet length = data length (len) + checksum (1) + end of stream marker (1)
abtTxBuf[3] = szTxLen;
@ -226,12 +225,13 @@ bool pn532_uart_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, con
#ifdef DEBUG
PRINT_HEX("TX", abtTxBuf,szTxLen+7);
#endif
if (!uart_send((serial_port)nds,abtTxBuf,szTxLen+7)) {
if (!uart_send((serial_port)pnd->nds,abtTxBuf,szTxLen+7)) {
ERR("%s", "Unable to transmit data. (TX)");
return false;
}
if (!uart_receive((serial_port)nds,abtRxBuf,&szRxBufLen)) {
szRxBufLen = 6;
if (!uart_receive((serial_port)pnd->nds,abtRxBuf,&szRxBufLen)) {
ERR("%s", "Unable to receive data. (RX)");
return false;
}
@ -240,31 +240,14 @@ bool pn532_uart_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, con
PRINT_HEX("RX", abtRxBuf,szRxBufLen);
#endif
if(szRxBufLen >= sizeof(pn53x_ack_frame)) {
if (!pn53x_transceive_callback(pnd, abtRxBuf, szRxBufLen))
return false;
// Check if PN53x reply ACK
if(0!=memcmp(pn53x_ack_frame, abtRxBuf, sizeof(pn53x_ack_frame))) {
DBG("%s", "PN53x doesn't respond ACK frame.");
if (0==memcmp(pn53x_nack_frame, abtRxBuf, sizeof(pn53x_nack_frame))) {
ERR("%s", "PN53x reply NACK frame.");
// FIXME Handle NACK frame i.e. resend frame, PN53x doesn't received it correctly
}
return false;
}
szRxBufLen = BUFFER_LENGTH;
szRxBufLen -= sizeof(pn53x_ack_frame);
if(szRxBufLen) {
memmove(abtRxBuf, abtRxBuf+sizeof(pn53x_ack_frame), szRxBufLen);
}
}
if(szRxBufLen == 0) {
// There was no more data than ACK frame, we need to wait next frame
DBG("%s", "There was no more data than ACK frame, we need to wait next frame");
while (!uart_receive((serial_port)nds,abtRxBuf,&szRxBufLen)) {
while (!uart_receive((serial_port)pnd->nds,abtRxBuf,&szRxBufLen)) {
delay_ms(10);
}
}
#ifdef DEBUG
PRINT_HEX("RX", abtRxBuf,szRxBufLen);

2
libnfc/drivers/pn532_uart.h
View file

@ -36,7 +36,7 @@ nfc_device_t* pn532_uart_connect(const nfc_device_desc_t* pndd);
void pn532_uart_disconnect(nfc_device_t* pnd);
// Callback function used by libnfc to transmit commands to the PN53X chip
bool pn532_uart_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
bool pn532_uart_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
#endif // ! __NFC_DRIVER_PN532_UART_H__

11
libnfc/drivers/pn53x_usb.c
View file

@ -38,6 +38,7 @@ Thanks to d18c7db and Okko for example code
#include <string.h>
#include "../drivers.h"
#include "../chips/pn53x.h"
#include <nfc/nfc-messages.h>
@ -235,13 +236,13 @@ void pn53x_usb_disconnect(nfc_device_t* pnd)
free(pnd);
}
bool pn53x_usb_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
bool pn53x_usb_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen)
{
size_t uiPos = 0;
int ret = 0;
byte_t abtTx[BUFFER_LENGTH] = { 0x00, 0x00, 0xff }; // Every packet must start with "00 00 ff"
byte_t abtRx[BUFFER_LENGTH];
usb_spec_t* pus = (usb_spec_t*)nds;
usb_spec_t* pus = (usb_spec_t*)pnd->nds;
// Packet length = data length (len) + checksum (1) + end of stream marker (1)
abtTx[3] = szTxLen;
@ -282,8 +283,9 @@ bool pn53x_usb_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, cons
PRINT_HEX("RX", abtRx,ret);
#endif
if( ret == 6 )
{
if (!pn53x_transceive_callback (pnd, abtRx, ret))
return false;
ret = usb_bulk_read(pus->pudh, pus->uiEndPointIn, (char*)abtRx, BUFFER_LENGTH, USB_TIMEOUT);
if( ret < 0 )
{
@ -294,7 +296,6 @@ bool pn53x_usb_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, cons
#ifdef DEBUG
PRINT_HEX("RX", abtRx,ret);
#endif
}
// When the answer should be ignored, just return a succesful result
if(pbtRx == NULL || pszRxLen == NULL) return true;

2
libnfc/drivers/pn53x_usb.h
View file

@ -37,5 +37,5 @@ typedef struct {
nfc_device_t* pn53x_usb_connect(const nfc_device_desc_t* pndd,const char * target_name, int target_chip);
void get_end_points(struct usb_device *dev, usb_spec_t* pus);
void pn53x_usb_disconnect(nfc_device_t* pnd);
bool pn53x_usb_transceive(const nfc_device_spec_t nds, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
bool pn53x_usb_transceive(nfc_device_t* pnd, const byte_t* pbtTx, const size_t szTxLen, byte_t* pbtRx, size_t* pszRxLen);
bool pn53x_usb_list_devices(nfc_device_desc_t pnddDevices[], size_t szDevices, size_t *pszDeviceFound,usb_candidate_t candidates[], int num_candidates, char * target_name);

4
libnfc/nfc.c
View file

@ -318,7 +318,7 @@ bool nfc_configure(nfc_device_t* pnd, const nfc_device_option_t ndo, const bool
* After initialization it can be used to communicate to passive RFID tags and active NFC devices.
* The reader will act as initiator to communicate peer 2 peer (NFCIP) to other active NFC devices.
*/
bool nfc_initiator_init(const nfc_device_t* pnd)
bool nfc_initiator_init(nfc_device_t* pnd)
{
// Make sure we are dealing with a active device
if (!pnd->bActive) return false;
@ -412,7 +412,7 @@ bool nfc_initiator_select_dep_target(nfc_device_t* pnd, const nfc_modulation_t n
* @note For every initial modulation type there is a different collection of information returned (in nfc_target_info_t pointer pti) They all fit in the data-type which is called nfc_target_info_t. This is a union which contains the tag information that belongs to the according initial modulation type.
*/
bool
nfc_initiator_select_passive_target(const nfc_device_t* pnd,
nfc_initiator_select_passive_target(nfc_device_t* pnd,
const nfc_modulation_t nmInitModulation,
const byte_t* pbtInitData, const size_t szInitDataLen,
nfc_target_info_t* pnti)