You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
703 lines
18 KiB
703 lines
18 KiB
/* |
|
* Copyright (C) 2016 TriaGnoSys GmbH |
|
* |
|
* This file is subject to the terms and conditions of the GNU Lesser |
|
* General Public License v2.1. See the file LICENSE in the top level |
|
* directory for more details. |
|
*/ |
|
|
|
/** |
|
* @ingroup drivers_pn532 |
|
* |
|
* @{ |
|
* @file |
|
* @brief PN532 driver |
|
* |
|
* @author Víctor Ariño <victor.arino@triagnosys.com> |
|
* @} |
|
*/ |
|
|
|
#include <stdio.h> |
|
#include <string.h> |
|
|
|
#include "assert.h" |
|
#include "xtimer.h" |
|
#include "mutex.h" |
|
#include "pn532.h" |
|
#include "periph/gpio.h" |
|
#include "periph/i2c.h" |
|
#include "periph/spi.h" |
|
|
|
#define ENABLE_DEBUG (0) |
|
#include "debug.h" |
|
|
|
#define PN532_I2C_ADDRESS (0x24) |
|
|
|
/* Commands */ |
|
#define CMD_FIRMWARE_VERSION (0x02) |
|
#define CMD_READ_REG (0x06) |
|
#define CMD_WRITE_REG (0x08) |
|
#define CMD_READ_GPIO (0x0c) |
|
#define CMD_WRITE_GPIO (0x0E) |
|
#define CMD_SAM_CONFIG (0x14) |
|
#define CMD_RF_CONFIG (0x32) |
|
#define CMD_DATA_EXCHANGE (0x40) |
|
#define CMD_DESELECT (0x44) |
|
#define CMD_LIST_PASSIVE (0x4a) |
|
#define CMD_RELEASE (0x52) |
|
|
|
/* Mifare specific commands */ |
|
#define MIFARE_CMD_READ (0x30) |
|
#define MIFARE_CMD_WRITE (0xA0) |
|
|
|
/* RF register settings */ |
|
#define RF_CONFIG_MAX_RETRIES (0x05) |
|
|
|
/* Buffer operations */ |
|
#define BUFF_CMD_START (6) |
|
#define BUFF_DATA_START (BUFF_CMD_START + 1) |
|
#define RAPDU_DATA_BEGIN (1) |
|
#define RAPDU_MAX_DATA_LEN (PN532_BUFFER_LEN - BUFF_DATA_START - 5) |
|
#define CAPDU_MAX_DATA_LEN (PN532_BUFFER_LEN - BUFF_DATA_START - 1) |
|
|
|
/* Constants and magic numbers */ |
|
#define MIFARE_CLASSIC_BLOCK_SIZE (16) |
|
#define RESET_TOGGLE_SLEEP (400000) |
|
#define RESET_BACKOFF (10000) |
|
#define HOST_TO_PN532 (0xD4) |
|
#define PN532_TO_HOST (0xD5) |
|
#define SPI_DATA_WRITE (0x80) |
|
#define SPI_STATUS_READING (0x40) |
|
#define SPI_DATA_READ (0xC0) |
|
#define SPI_WRITE_DELAY_US (2000) |
|
|
|
/* SPI bus parameters */ |
|
#define SPI_MODE (SPI_MODE_0) |
|
#define SPI_CLK (SPI_CLK_1MHZ) |
|
|
|
/* Length for passive listings */ |
|
#define LIST_PASSIVE_LEN_14443(num) (num * 20) |
|
|
|
#if ENABLE_DEBUG |
|
#define PRINTBUFF printbuff |
|
static void printbuff(char *buff, unsigned len) |
|
{ |
|
while (len) { |
|
len--; |
|
printf("%02x ", *buff++); |
|
} |
|
printf("\n"); |
|
} |
|
#else |
|
#define PRINTBUFF(...) |
|
#endif |
|
|
|
static void _nfc_event(void *dev) |
|
{ |
|
mutex_unlock(&((pn532_t *)dev)->trap); |
|
} |
|
|
|
void pn532_reset(pn532_t *dev) |
|
{ |
|
assert(dev != NULL); |
|
|
|
DEBUG("pn532: reset\n"); |
|
gpio_clear(dev->conf->reset); |
|
xtimer_usleep(RESET_TOGGLE_SLEEP); |
|
gpio_set(dev->conf->reset); |
|
xtimer_usleep(RESET_BACKOFF); |
|
} |
|
|
|
int pn532_init(pn532_t *dev, const pn532_params_t *params, pn532_mode_t mode) |
|
{ |
|
assert(dev != NULL); |
|
|
|
dev->conf = params; |
|
|
|
gpio_init_int(dev->conf->irq, GPIO_IN_PU, GPIO_FALLING, |
|
_nfc_event, (void *)dev); |
|
|
|
gpio_init(dev->conf->reset, GPIO_OUT); |
|
gpio_set(dev->conf->reset); |
|
dev->mode = mode; |
|
if (mode == PN532_I2C) { |
|
#ifdef PN532_SUPPORT_I2C |
|
if (i2c_init_master(dev->conf->i2c, I2C_SPEED_FAST) != 0) { |
|
DEBUG("pn532: initialization of I2C bus failed\n"); |
|
return -1; |
|
} |
|
#endif |
|
} |
|
else { |
|
#ifdef PN532_SUPPORT_SPI |
|
/* we handle the CS line manually... */ |
|
gpio_init(dev->conf->nss, GPIO_OUT); |
|
gpio_set(dev->conf->nss); |
|
#endif |
|
} |
|
|
|
pn532_reset(dev); |
|
|
|
mutex_init(&dev->trap); |
|
mutex_lock(&dev->trap); |
|
|
|
return 0; |
|
} |
|
|
|
static unsigned char chksum(char *b, unsigned len) |
|
{ |
|
unsigned char c = 0x00; |
|
|
|
while (len--) { |
|
c -= *b++; |
|
} |
|
return c; |
|
} |
|
|
|
#ifdef PN532_SUPPORT_SPI |
|
static void reverse(char *buff, unsigned len) |
|
{ |
|
while (len--) { |
|
buff[len] = (buff[len] & 0xF0) >> 4 | (buff[len] & 0x0F) << 4; |
|
buff[len] = (buff[len] & 0xCC) >> 2 | (buff[len] & 0x33) << 2; |
|
buff[len] = (buff[len] & 0xAA) >> 1 | (buff[len] & 0x55) << 1; |
|
} |
|
} |
|
#endif |
|
|
|
static int _write(pn532_t *dev, char *buff, unsigned len) |
|
{ |
|
int ret = -1; |
|
|
|
(void)buff; |
|
(void)len; |
|
|
|
if (dev->mode == PN532_I2C) { |
|
#ifdef PN532_SUPPORT_I2C |
|
i2c_acquire(dev->conf->i2c); |
|
ret = i2c_write_bytes(dev->conf->i2c, PN532_I2C_ADDRESS, buff, len); |
|
i2c_release(dev->conf->i2c); |
|
#endif |
|
} |
|
else { |
|
#ifdef PN532_SUPPORT_SPI |
|
spi_acquire(dev->conf->spi, SPI_CS_UNDEF, SPI_MODE, SPI_CLK); |
|
gpio_clear(dev->conf->nss); |
|
xtimer_usleep(SPI_WRITE_DELAY_US); |
|
reverse(buff, len); |
|
spi_transfer_byte(dev->conf->spi, SPI_CS_UNDEF, true, SPI_DATA_WRITE); |
|
spi_transfer_bytes(dev->conf->spi, SPI_CS_UNDEF, true, buff, NULL, len); |
|
gpio_set(dev->conf->nss); |
|
spi_release(dev->conf->spi); |
|
ret = (int)len; |
|
#endif |
|
} |
|
DEBUG("pn532: -> "); |
|
PRINTBUFF(buff, len); |
|
return ret; |
|
} |
|
|
|
static int _read(pn532_t *dev, char *buff, unsigned len) |
|
{ |
|
int ret = -1; |
|
|
|
(void)buff; |
|
(void)len; |
|
|
|
if (dev->mode == PN532_I2C) { |
|
#ifdef PN532_SUPPORT_I2C |
|
i2c_acquire(dev->conf->i2c); |
|
/* len+1 for RDY after read is accepted */ |
|
ret = i2c_read_bytes(dev->conf->i2c, PN532_I2C_ADDRESS, buff, len + 1); |
|
i2c_release(dev->conf->i2c); |
|
#endif |
|
} |
|
else { |
|
#ifdef PN532_SUPPORT_SPI |
|
spi_acquire(dev->conf->spi, SPI_CS_UNDEF, SPI_MODE, SPI_CLK); |
|
gpio_clear(dev->conf->nss); |
|
spi_transfer_byte(dev->conf->spi, SPI_CS_UNDEF, true, SPI_DATA_READ); |
|
spi_transfer_bytes(dev->conf->spi, SPI_CS_UNDEF, true, NULL, &buff[1], len); |
|
gpio_set(dev->conf->nss); |
|
spi_release(dev->conf->spi); |
|
|
|
buff[0] = 0x80; |
|
reverse(buff, len); |
|
ret = (int)len + 1; |
|
#endif |
|
} |
|
DEBUG("pn532: <- "); |
|
PRINTBUFF(buff, len); |
|
return ret; |
|
} |
|
|
|
static int send_cmd(pn532_t *dev, char *buff, unsigned len) |
|
{ |
|
unsigned pos, checksum; |
|
|
|
buff[0] = 0x00; |
|
buff[1] = 0x00; |
|
buff[2] = 0xFF; |
|
|
|
len += 1; |
|
if (len < 0xff) { |
|
buff[3] = (char)len; |
|
buff[4] = 0x00 - buff[3]; |
|
pos = 5; |
|
|
|
} |
|
else { |
|
buff[3] = 0xff; |
|
buff[4] = 0xff; |
|
buff[5] = (len >> 8) & 0xff; |
|
buff[6] = (len) & 0xff; |
|
buff[7] = 0x00 - buff[5] - buff[6]; |
|
pos = 8; |
|
} |
|
|
|
buff[pos] = HOST_TO_PN532; |
|
checksum = chksum(&buff[pos], len); |
|
|
|
len += pos; |
|
buff[len++] = checksum; |
|
buff[len++] = 0x00; |
|
|
|
return _write(dev, buff, len); |
|
} |
|
|
|
static void wait_ready(pn532_t *dev) |
|
{ |
|
mutex_lock(&dev->trap); |
|
} |
|
|
|
/* Returns >0 payload len (or <0 received len but not as expected) */ |
|
static int read_command(pn532_t *dev, char *buff, unsigned len, int expected_cmd) |
|
{ |
|
int r; |
|
unsigned j, fi, lp, lc; |
|
|
|
/* apply framing overhead */ |
|
len += 8; |
|
if (len >= 0xff) { |
|
len += 3; |
|
} |
|
|
|
r = _read(dev, buff, len); |
|
|
|
/* Validate frame structure and CRCs |
|
* |
|
* Note that all offsets are shifted by one since the first byte is always |
|
* 0x01. */ |
|
if ((r < len) || (buff[1] != 0x00) || (buff[2] != 0x00) || (buff[3] != 0xFF)) { |
|
return -r; |
|
} |
|
|
|
if (buff[4] == 0xff && buff[5] == 0xff) { |
|
/* extended frame */ |
|
lp = buff[6] << 8 | buff[7]; |
|
lc = (buff[6] + buff[7] + buff[8]) & 0xff; |
|
fi = 9; |
|
|
|
} |
|
else { |
|
/* normal frame */ |
|
lp = buff[4]; |
|
lc = (buff[4] + buff[5]) & 0xff; |
|
fi = 6; |
|
} |
|
|
|
if (lc != 0 || lp >= 265 || buff[fi] != PN532_TO_HOST) { |
|
return -r; |
|
} |
|
|
|
if (lp == 0) { |
|
return -r; |
|
} |
|
|
|
if (chksum(&buff[fi], lp) != buff[fi + lp]) { |
|
return -r; |
|
} |
|
|
|
if (buff[fi + 1] != expected_cmd) { |
|
return -r; |
|
} |
|
|
|
/* Move the meaningful data to the beginning of the buffer */ |
|
/* start copying after command byte */ |
|
for (j = 0, fi += 2, lp -= 2; j < lp; fi++, j++) { |
|
buff[j] = buff[fi]; |
|
} |
|
|
|
DEBUG("pn532: in cmd "); |
|
PRINTBUFF(buff, lp); |
|
|
|
return lp; |
|
} |
|
|
|
/* Returns 0 if OK, <0 otherwise */ |
|
static int send_check_ack(pn532_t *dev, char *buff, unsigned len) |
|
{ |
|
if (send_cmd(dev, buff, len) > 0) { |
|
static char ack[] = { 0x00, 0x00, 0xff, 0x00, 0xff, 0x00 }; |
|
|
|
wait_ready(dev); |
|
if (_read(dev, buff, sizeof(ack)) != sizeof(ack) + 1) { |
|
return -2; |
|
} |
|
|
|
if (memcmp(&buff[1], ack, sizeof(ack)) != 0) { |
|
return -3; |
|
} |
|
|
|
wait_ready(dev); |
|
return 0; |
|
} |
|
|
|
return -1; |
|
} |
|
|
|
/* sendl: send length, recvl: receive payload length */ |
|
static int send_rcv(pn532_t *dev, char *buff, unsigned sendl, unsigned recvl) |
|
{ |
|
assert(dev != NULL); |
|
|
|
int expected_cmd = buff[BUFF_CMD_START] + 1; |
|
|
|
if (send_check_ack(dev, buff, sendl + 1)) { |
|
return 0; |
|
} |
|
|
|
recvl += 1; /* cmd response */ |
|
return read_command(dev, buff, recvl, expected_cmd); |
|
} |
|
|
|
int pn532_fw_version(pn532_t *dev, uint32_t *fw_ver) |
|
{ |
|
unsigned ret = -1; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START] = CMD_FIRMWARE_VERSION; |
|
|
|
if (send_rcv(dev, buff, 0, 4) == 4) { |
|
*fw_ver = (buff[0] << 24); /* ic version */ |
|
*fw_ver += (buff[1] << 16); /* fw ver */ |
|
*fw_ver += (buff[2] << 8); /* fw rev */ |
|
*fw_ver += (buff[3]); /* feature support */ |
|
ret = 0; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
int pn532_read_reg(pn532_t *dev, char *out, unsigned addr) |
|
{ |
|
int ret = -1; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_READ_REG; |
|
buff[BUFF_DATA_START ] = (addr >> 8) & 0xff; |
|
buff[BUFF_DATA_START + 1] = addr & 0xff; |
|
|
|
if (send_rcv(dev, buff, 2, 1) == 1) { |
|
*out = buff[0]; |
|
ret = 0; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
int pn532_write_reg(pn532_t *dev, unsigned addr, char val) |
|
{ |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_WRITE_REG; |
|
buff[BUFF_DATA_START ] = (addr >> 8) & 0xff; |
|
buff[BUFF_DATA_START + 1] = addr & 0xff; |
|
buff[BUFF_DATA_START + 2] = val; |
|
|
|
return send_rcv(dev, buff, 3, 0); |
|
} |
|
|
|
static int _rf_configure(pn532_t *dev, char *buff, unsigned cfg_item, char *config, |
|
unsigned cfg_len) |
|
{ |
|
buff[BUFF_CMD_START ] = CMD_RF_CONFIG; |
|
buff[BUFF_DATA_START] = cfg_item; |
|
for (int i = 1; i <= cfg_len; i++) { |
|
buff[BUFF_DATA_START + i] = *config++; |
|
} |
|
|
|
return send_rcv(dev, buff, cfg_len + 1, 0); |
|
} |
|
|
|
static int _set_act_retries(pn532_t *dev, char *buff, unsigned max_retries) |
|
{ |
|
char rtrcfg[] = { 0xff, 0x01, max_retries & 0xff }; |
|
|
|
return _rf_configure(dev, buff, RF_CONFIG_MAX_RETRIES, rtrcfg, sizeof(rtrcfg)); |
|
} |
|
|
|
int pn532_sam_configuration(pn532_t *dev, pn532_sam_conf_mode_t mode, unsigned timeout) |
|
{ |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_SAM_CONFIG; |
|
buff[BUFF_DATA_START ] = (char)mode; |
|
buff[BUFF_DATA_START + 1] = (char)(timeout / 50); |
|
buff[BUFF_DATA_START + 2] = 0x01; |
|
|
|
return send_rcv(dev, buff, 3, 0); |
|
} |
|
|
|
static int _list_passive_targets(pn532_t *dev, char *buff, pn532_target_t target, |
|
unsigned max, unsigned recvl) |
|
{ |
|
buff[BUFF_CMD_START] = CMD_LIST_PASSIVE; |
|
buff[BUFF_DATA_START] = (char) max; |
|
buff[BUFF_DATA_START + 1] = (char)target; |
|
|
|
/* requested len depends on expected target num and type */ |
|
return send_rcv(dev, buff, 2, recvl); |
|
} |
|
|
|
int pn532_get_passive_iso14443a(pn532_t *dev, nfc_iso14443a_t *out, |
|
unsigned max_retries) |
|
{ |
|
int ret = -1; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
if (_set_act_retries(dev, buff, max_retries) == 0) { |
|
ret = _list_passive_targets(dev, buff, PN532_BR_106_ISO_14443_A, 1, |
|
LIST_PASSIVE_LEN_14443(1)); |
|
} |
|
|
|
if (ret > 0 && buff[0] > 0) { |
|
out->target = buff[1]; |
|
out->sns_res = (buff[2] << 8) | buff[3]; |
|
out->sel_res = buff[4]; |
|
out->id_len = buff[5]; |
|
out->type = ISO14443A_UNKNOWN; |
|
|
|
for (int i = 0; i < out->id_len; i++) { |
|
out->id[i] = buff[6 + i]; |
|
} |
|
|
|
/* try to find out the type */ |
|
if (out->id_len == 4) { |
|
out->type = ISO14443A_MIFARE; |
|
} |
|
else if (out->id_len == 7) { |
|
/* In the case of type 4, the first byte of RATS is the length |
|
* of RATS including the length itself (6+7) */ |
|
if (buff[13] == ret - 13) { |
|
out->type = ISO14443A_TYPE4; |
|
} |
|
} |
|
ret = 0; |
|
} |
|
else { |
|
ret = -1; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
void pn532_deselect_passive(pn532_t *dev, unsigned target_id) |
|
{ |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_DESELECT; |
|
buff[BUFF_DATA_START] = target_id; |
|
|
|
send_rcv(dev, buff, 1, 1); |
|
} |
|
|
|
void pn532_release_passive(pn532_t *dev, unsigned target_id) |
|
{ |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_RELEASE; |
|
buff[BUFF_DATA_START] = target_id; |
|
|
|
send_rcv(dev, buff, 1, 1); |
|
} |
|
|
|
int pn532_mifareclassic_authenticate(pn532_t *dev, nfc_iso14443a_t *card, |
|
pn532_mifare_key_t keyid, char *key, unsigned block) |
|
{ |
|
int ret = -1; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_DATA_EXCHANGE; |
|
buff[BUFF_DATA_START ] = card->target; |
|
buff[BUFF_DATA_START + 1] = keyid; |
|
buff[BUFF_DATA_START + 2] = block; /* current block */ |
|
|
|
/* |
|
* The card ID directly follows the key in the buffer |
|
* The key consists of 6 bytes and starts at offset 3 |
|
*/ |
|
for (int i = 0; i < 6; i++) { |
|
buff[BUFF_DATA_START + 3 + i] = key[i]; |
|
} |
|
|
|
for (int i = 0; i < card->id_len; i++) { |
|
buff[BUFF_DATA_START + 9 + i] = card->id[i]; |
|
} |
|
|
|
ret = send_rcv(dev, buff, 9 + card->id_len, 1); |
|
if (ret == 1) { |
|
ret = buff[0]; |
|
card->auth = 1; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
int pn532_mifareclassic_write(pn532_t *dev, char *idata, nfc_iso14443a_t *card, |
|
unsigned block) |
|
{ |
|
int ret = -1; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
if (card->auth) { |
|
|
|
buff[BUFF_CMD_START ] = CMD_DATA_EXCHANGE; |
|
buff[BUFF_DATA_START ] = card->target; |
|
buff[BUFF_DATA_START + 1] = MIFARE_CMD_WRITE; |
|
buff[BUFF_DATA_START + 2] = block; /* current block */ |
|
memcpy(&buff[BUFF_DATA_START + 3], idata, MIFARE_CLASSIC_BLOCK_SIZE); |
|
|
|
if (send_rcv(dev, buff, 19, 1) == 1) { |
|
ret = buff[0]; |
|
} |
|
|
|
} |
|
return ret; |
|
} |
|
|
|
static int pn532_mifare_read(pn532_t *dev, char *odata, nfc_iso14443a_t *card, |
|
unsigned block, unsigned len) |
|
{ |
|
int ret = -1; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_DATA_EXCHANGE; |
|
buff[BUFF_DATA_START ] = card->target; |
|
buff[BUFF_DATA_START + 1] = MIFARE_CMD_READ; |
|
buff[BUFF_DATA_START + 2] = block; /* current block */ |
|
|
|
if (send_rcv(dev, buff, 3, len + 1) == len + 1) { |
|
memcpy(odata, &buff[1], len); |
|
ret = 0; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
int pn532_mifareclassic_read(pn532_t *dev, char *odata, nfc_iso14443a_t *card, |
|
unsigned block) |
|
{ |
|
if (card->auth) { |
|
return pn532_mifare_read(dev, odata, card, block, MIFARE_CLASSIC_BLOCK_SIZE); |
|
} |
|
else { |
|
return -1; |
|
} |
|
} |
|
|
|
int pn532_mifareulight_read(pn532_t *dev, char *odata, nfc_iso14443a_t *card, |
|
unsigned page) |
|
{ |
|
return pn532_mifare_read(dev, odata, card, page, 32); |
|
} |
|
|
|
static int send_rcv_apdu(pn532_t *dev, char *buff, unsigned slen, unsigned rlen) |
|
{ |
|
int ret; |
|
|
|
rlen += 3; |
|
if (rlen >= RAPDU_MAX_DATA_LEN) { |
|
return -1; |
|
|
|
} |
|
else if (slen >= CAPDU_MAX_DATA_LEN) { |
|
return -1; |
|
} |
|
|
|
ret = send_rcv(dev, buff, slen, rlen); |
|
if (ret == rlen && buff[0] == 0x00) { |
|
ret = (buff[rlen - 2] << 8) | buff[rlen - 1]; |
|
if (ret == 0x9000) { |
|
ret = 0; |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
int pn532_iso14443a_4_activate(pn532_t *dev, nfc_iso14443a_t *card) |
|
{ |
|
int ret; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
/* select app ndef tag */ |
|
buff[BUFF_CMD_START ] = CMD_DATA_EXCHANGE; |
|
buff[BUFF_DATA_START ] = card->target; |
|
buff[BUFF_DATA_START + 1] = 0x00; |
|
buff[BUFF_DATA_START + 2] = 0xa4; |
|
buff[BUFF_DATA_START + 3] = 0x04; |
|
buff[BUFF_DATA_START + 4] = 0x00; |
|
buff[BUFF_DATA_START + 5] = 0x07; |
|
buff[BUFF_DATA_START + 6] = 0xD2; |
|
buff[BUFF_DATA_START + 7] = 0x76; |
|
buff[BUFF_DATA_START + 8] = 0x00; |
|
buff[BUFF_DATA_START + 9] = 0x00; |
|
buff[BUFF_DATA_START + 10] = 0x85; |
|
buff[BUFF_DATA_START + 11] = 0x01; |
|
buff[BUFF_DATA_START + 12] = 0x01; |
|
buff[BUFF_DATA_START + 13] = 0x00; |
|
|
|
DEBUG("pn532: select app\n"); |
|
ret = send_rcv_apdu(dev, buff, 14, 0); |
|
|
|
/* select ndef file */ |
|
buff[BUFF_CMD_START ] = CMD_DATA_EXCHANGE; |
|
buff[BUFF_DATA_START ] = card->target; |
|
buff[BUFF_DATA_START + 1] = 0x00; |
|
buff[BUFF_DATA_START + 2] = 0xa4; |
|
buff[BUFF_DATA_START + 3] = 0x00; |
|
buff[BUFF_DATA_START + 4] = 0x0c; |
|
buff[BUFF_DATA_START + 5] = 0x02; |
|
buff[BUFF_DATA_START + 6] = 0x00; |
|
buff[BUFF_DATA_START + 7] = 0x01; |
|
|
|
if (ret == 0) { |
|
DEBUG("pn532: select file\n"); |
|
ret = send_rcv_apdu(dev, buff, 8, 0); |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
int pn532_iso14443a_4_read(pn532_t *dev, char *odata, nfc_iso14443a_t *card, |
|
unsigned offset, char len) |
|
{ |
|
int ret; |
|
char buff[PN532_BUFFER_LEN]; |
|
|
|
buff[BUFF_CMD_START ] = CMD_DATA_EXCHANGE; |
|
buff[BUFF_DATA_START ] = card->target; |
|
buff[BUFF_DATA_START + 1] = 0x00; |
|
buff[BUFF_DATA_START + 2] = 0xb0; |
|
buff[BUFF_DATA_START + 3] = (offset >> 8) & 0xff; |
|
buff[BUFF_DATA_START + 4] = offset & 0xff; |
|
buff[BUFF_DATA_START + 5] = len; |
|
|
|
ret = send_rcv_apdu(dev, buff, 6, len); |
|
if (ret == 0) { |
|
memcpy(odata, &buff[RAPDU_DATA_BEGIN], len); |
|
} |
|
|
|
return ret; |
|
}
|
|
|