#include <stdio.h>
+enum rfid_frametype {
+ RFID_14443A_FRAME_REGULAR,
+ RFID_14443B_FRAME_REGULAR,
+ RFID_MIFARE_FRAME,
+};
+
+
#define DEBUGP(x, args ...) fprintf(stderr, "%s(%d):%s: " x, __FILE__, __LINE__, __FUNCTION__, ## args)
#define DEBUGPC(x, args ...) fprintf(stderr, x, ## args)
#ifndef _RFID_ASIC_H
#define _RFID_ASIC_H
+enum rfid_frametype;
+
#include <rfid/rfid_asic_rc632.h>
struct rfid_asic_transport {
struct rfid_asic_transport_handle;
+#include <rfid/rfid_asic.h>
+
struct rfid_asic_rc632_transport {
struct {
int (*reg_write)(struct rfid_asic_transport_handle *rath,
int (*turn_on_rf)(struct rfid_asic_handle *h);
int (*turn_off_rf)(struct rfid_asic_handle *h);
int (*transcieve)(struct rfid_asic_handle *h,
+ enum rfid_frametype,
const u_int32_t *tx_buf,
unsigned int tx_len,
u_int32_t *rx_buf,
int (*init)(struct rfid_asic_handle *h);
} iso15693;
struct {
- int (*setkey)(struct rfid_asic_handle *h, unsigned char *key);
+ int (*setkey)(struct rfid_asic_handle *h,
+ const unsigned char *key);
int (*auth)(struct rfid_asic_handle *h, u_int8_t cmd,
u_int32_t serno, u_int8_t block);
} mifare_classic;
struct rfid_layer2_handle;
struct rfid_reader_handle;
+#include <rfid/rfid.h>
+
#include <rfid/rfid_layer2_iso14443a.h>
#include <rfid/rfid_layer2_iso14443b.h>
#include <rfid/rfid_layer2_iso15693.h>
struct rfid_layer2_handle *(*init)(struct rfid_reader_handle *h);
int (*open)(struct rfid_layer2_handle *h);
int (*transcieve)(struct rfid_layer2_handle *h,
+ enum rfid_frametype frametype,
const unsigned char *tx_buf,
unsigned int tx_len, unsigned char *rx_buf,
unsigned int *rx_len, u_int64_t timeout,
unsigned int id);
int rfid_layer2_open(struct rfid_layer2_handle *l2h);
int rfid_layer2_transcieve(struct rfid_layer2_handle *l2h,
+ enum rfid_frametype frametype,
const unsigned char *tx_buf, unsigned int tx_len,
unsigned char *rx_buf, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags);
#define RFID_CMD_MIFARE_AUTH1A 0x60
#define RFID_CMD_MIFARE_AUTH1B 0x61
-#define MIFARE_CLASSIC_KEY_DEFAULT "\xa0\xa1\xa2\xa3\xa4\xa5"
+#define MIFARE_CL_CMD_WRITE16 0xA0
+#define MIFARE_CL_CMD_READ 0x30
+
+#define MIFARE_CL_RESP_ACK 0x0a
+#define MIFARE_CL_RESP_NAK 0x00
+
+#define MIFARE_CL_PAGE_MAX 0xff
+
+#define MIFARE_CLASSIC_KEYA_DEFAULT "\xa0\xa1\xa2\xa3\xa4\xa5"
+#define MIFARE_CLASSIC_KEYB_DEFAULT "\xb0\xb1\xb2\xb3\xb4\xb5"
#endif
char *name;
unsigned int id;
int (*transcieve)(struct rfid_reader_handle *h,
+ enum rfid_frametype frametype,
const unsigned char *tx_buf, unsigned int tx_len,
unsigned char *rx_buf, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags);
} priv;
struct rfid_reader *reader;
};
+
+
+extern struct rfid_reader_handle *
+rfid_reader_open(void *data, unsigned int id);
+
+extern void rfid_reader_close(struct rfid_reader_handle *rh);
#endif
return iso7816_read_binary(buf, len);
}
+/* mifare ultralight helpers */
int
mifare_ulight_write(struct rfid_protocol_handle *ph)
{
unsigned char buf[4] = { 0xa1, 0xa2, 0xa3, 0xa4 };
- return rfid_protocol_write(ph, 20, buf, 4);
+ return rfid_protocol_write(ph, 10, buf, 4);
}
int
return 0;
}
-int
+static int
mifare_ulight_read(struct rfid_protocol_handle *ph)
{
unsigned char buf[20];
return 0;
}
+/* mifare classic helpers */
+static int
+mifare_classic_read(struct rfid_protocol_handle *ph)
+{
+ unsigned char buf[20];
+ unsigned int len = sizeof(buf);
+ int ret;
+ int i;
+
+ for (i = 0; i <= MIFARE_CL_PAGE_MAX; i++) {
+ ret = rfid_protocol_read(ph, i, buf, &len);
+ if (ret < 0)
+ return ret;
+
+ printf("Page 0x%x: %s\n", i, rfid_hexdump(buf, 4));
+ }
+ return 0;
+}
+
+
int main(int argc, char **argv)
{
int rc;
if (init() < 0)
exit(1);
- protocol = RFID_PROTOCOL_MIFARE_UL;
- protocol = RFID_PROTOCOL_MIFARE_CLASSIC;
-// protocol = RFID_PROTOCOL_TCL;
+ //protocol = RFID_PROTOCOL_MIFARE_UL;
+ //protocol = RFID_PROTOCOL_MIFARE_CLASSIC;
+ protocol = RFID_PROTOCOL_TCL;
if (l3(protocol) < 0)
exit(1);
/* we've established T=CL at this point */
select_mf();
- rc632_register_dump(rh->ah, buf);
- select_mf();
+ //rc632_register_dump(rh->ah, buf);
+ //select_mf();
iso7816_select_application();
iso7816_select_ef(0x011e);
case RFID_PROTOCOL_MIFARE_UL:
mifare_ulight_read(ph);
#if 0
- //mifare_ulight_blank(ph);
- mifare_ulight_write(ph);
+ mifare_ulight_blank(ph);
+ //mifare_ulight_write(ph);
mifare_ulight_read(ph);
#endif
break;
case RFID_PROTOCOL_MIFARE_CLASSIC:
- mfcl_set_key(ph, MIFARE_CLASSIC_KEY_DEFAULT);
- rc = mfcl_auth(ph, RFID_CMD_MIFARE_AUTH1A, 0);
+ rc = mfcl_set_key(ph, MIFARE_CLASSIC_KEYB_DEFAULT);
+ if (rc < 0) {
+ printf("key format error\n");
+ exit(1);
+ }
+ //mfcl_set_key(ph, "xasdfr");
+ rc = mfcl_auth(ph, RFID_CMD_MIFARE_AUTH1B, 10);
if (rc < 0) {
printf("mifare auth error\n");
exit(1);
} else
printf("mifare authe succeeded!\n");
+ mifare_classic_read(ph);
break;
}
struct rfid_asic rc632;
/* Register and FIFO Access functions */
-int
+static int
rc632_reg_write(struct rfid_asic_handle *handle,
u_int8_t reg,
u_int8_t val)
return handle->rath->rat->priv.rc632.fn.reg_write(handle->rath, reg, val);
}
-int
+static int
rc632_reg_read(struct rfid_asic_handle *handle,
u_int8_t reg,
u_int8_t *val)
return handle->rath->rat->priv.rc632.fn.reg_read(handle->rath, reg, val);
}
-int
+static int
rc632_fifo_write(struct rfid_asic_handle *handle,
u_int8_t len,
const u_int8_t *buf,
len, buf, flags);
}
-int
+static int
rc632_fifo_read(struct rfid_asic_handle *handle,
u_int8_t len,
u_int8_t *buf)
}
-int
+static int
rc632_set_bits(struct rfid_asic_handle *handle,
u_int8_t reg,
u_int8_t val)
return rc632_reg_write(handle, reg, (tmp|val)&0xff);
}
-int
+static int
rc632_clear_bits(struct rfid_asic_handle *handle,
u_int8_t reg,
u_int8_t val)
return rc632_reg_write(handle, reg, (tmp & ~val)&0xff);
}
-
-
-int
+static int
rc632_turn_on_rf(struct rfid_asic_handle *handle)
{
ENTER();
return rc632_set_bits(handle, RC632_REG_TX_CONTROL, 0x03);
}
-int
+static int
rc632_turn_off_rf(struct rfid_asic_handle *handle)
{
ENTER();
return rc632_clear_bits(handle, RC632_REG_TX_CONTROL, 0x03);
}
-int
+static int
rc632_power_up(struct rfid_asic_handle *handle)
{
ENTER();
RC632_CONTROL_POWERDOWN);
}
-int
+static int
rc632_power_down(struct rfid_asic_handle *handle)
{
return rc632_set_bits(handle, RC632_REG_CONTROL,
/* Stupid RC623 implementations don't evaluate interrupts but poll the
* command register for "status idle" */
-int
+static int
rc632_wait_idle(struct rfid_asic_handle *handle, u_int64_t timeout)
{
u_int8_t cmd = 0xff;
return 0;
}
-int
+static int
rc632_transmit(struct rfid_asic_handle *handle,
const u_int8_t *buf,
u_int8_t len,
return 0;
}
-int
+static int
rc632_transcieve(struct rfid_asic_handle *handle,
const u_int8_t *tx_buf,
u_int8_t tx_len,
return rc632_fifo_read(handle, *rx_len, rx_buf);
}
-int
+static int
rc632_read_eeprom(struct rfid_asic_handle *handle)
{
u_int8_t recvbuf[60];
return ret;
}
-int
+static int
rc632_calc_crc16_from(struct rfid_asic_handle *handle)
{
u_int8_t sndbuf[2] = { 0x01, 0x02 };
/* transcieve regular frame */
static int
-rc632_iso14443a_transcieve(struct rfid_asic_handle *handle,
+rc632_iso14443ab_transcieve(struct rfid_asic_handle *handle,
+ unsigned int frametype,
const u_int8_t *tx_buf, unsigned int tx_len,
u_int8_t *rx_buf, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags)
{
int ret;
u_int8_t rxl = *rx_len & 0xff;
+ u_int8_t channel_red;
DEBUGP("entered\n");
memset(rx_buf, 0, *rx_len);
+ switch (frametype) {
+ case RFID_14443A_FRAME_REGULAR:
+ case RFID_14443B_FRAME_REGULAR:
+ channel_red = RC632_CR_TX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE
+ |RC632_CR_PARITY_ENABLE|RC632_CR_PARITY_ODD;
+ break;
+ case RFID_MIFARE_FRAME:
+ channel_red = RC632_CR_PARITY_ENABLE|RC632_CR_PARITY_ODD;
+ break;
+ }
#if 0
ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
(RC632_CR_PARITY_ENABLE |
RC632_CR_TX_CRC_ENABLE |
RC632_CR_RX_CRC_ENABLE));
#endif
- ret = rc632_set_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
- RC632_CR_TX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
+ ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
+ channel_red);
if (ret < 0)
return ret;
rc632_mifare_set_key(struct rfid_asic_handle *h, const u_int8_t *key)
{
u_int8_t coded_key[RFID_MIFARE_KEY_CODED_LEN];
+ u_int8_t reg;
int ret;
ret = rc632_mifare_transform_key(key, coded_key);
if (ret < 0)
return ret;
+ ret = rc632_reg_read(h, RC632_REG_ERROR_FLAG, ®);
+ if (ret < 0)
+ return ret;
+
+ if (reg & RC632_ERR_FLAG_KEY_ERR)
+ return -EINVAL;
+
return 0;
}
/* Initialize acmd */
acmd.block_address = block & 0xff;
acmd.auth_cmd = cmd;
+ //acmd.serno = htonl(serno);
acmd.serno = serno;
+ ret = rc632_clear_bits(h, RC632_REG_CONTROL,
+ RC632_CONTROL_CRYPTO1_ON);
+
+ /* Clear Rx CRC */
+ ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
+ RC632_CR_RX_CRC_ENABLE);
+ if (ret < 0)
+ return ret;
+
/* Send Authent1 Command */
- ret = rc632_fifo_write(h, sizeof(acmd), &acmd, 0x03);
+ ret = rc632_fifo_write(h, sizeof(acmd), (unsigned char *)&acmd, 0x03);
if (ret < 0)
return ret;
if (ret < 0)
return ret;
- /* Clear Rx/Tx CRC */
+ ret = rc632_reg_read(h, RC632_REG_SECONDARY_STATUS, ®);
+ if (ret < 0)
+ return ret;
+ if (reg & 0x07)
+ return -EIO;
+
+ /* Clear Tx CRC */
ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
- RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
+ RC632_CR_TX_CRC_ENABLE);
if (ret < 0)
return ret;
if (ret < 0)
return ret;
+#if 0
/* Wait until transmitter is idle */
ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
if (ret < 0)
return ret;
+#else
+ sleep(1);
+#endif
/* Check whether authentication was successful */
ret = rc632_reg_read(h, RC632_REG_CONTROL, ®);
}
+/* transcieve regular frame */
+static int
+rc632_mifare_transcieve(struct rfid_asic_handle *handle,
+ const u_int8_t *tx_buf, unsigned int tx_len,
+ u_int8_t *rx_buf, unsigned int *rx_len,
+ u_int64_t timeout, unsigned int flags)
+{
+ int ret;
+ u_int8_t rxl = *rx_len & 0xff;
+
+ DEBUGP("entered\n");
+ memset(rx_buf, 0, *rx_len);
+
+#if 0
+ ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
+ (RC632_CR_PARITY_ENABLE |
+ RC632_CR_PARITY_ODD |
+ RC632_CR_TX_CRC_ENABLE |
+ RC632_CR_RX_CRC_ENABLE));
+#endif
+ ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
+ RC632_CR_TX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
+ if (ret < 0)
+ return ret;
+
+ ret = rc632_transcieve(handle, tx_buf, tx_len, rx_buf, &rxl, 0x32, 0);
+ *rx_len = rxl;
+ if (ret < 0)
+ return ret;
+
+
+ return 0;
+}
+
struct rfid_asic rc632 = {
.name = "Philips CL RC632",
.fc = ISO14443_FREQ_CARRIER,
.priv.rc632 = {
- .fn.power_up = &rc632_power_up,
- .fn.power_down = &rc632_power_down,
- .fn.turn_on_rf = &rc632_turn_on_rf,
- .fn.turn_off_rf = &rc632_turn_off_rf,
- .fn.transcieve = &rc632_iso14443a_transcieve,
- .fn.iso14443a = {
- .init = &rc632_iso14443a_init,
- .transcieve_sf = &rc632_iso14443a_transcieve_sf,
- .transcieve_acf = &rc632_iso14443a_transcieve_acf,
- },
- .fn.iso14443b = {
- .init = &rc632_iso14443b_init,
- },
- .fn.iso15693 = {
- .init = &rc632_iso15693_init,
- },
- .fn.mifare_classic = {
- .setkey = &rc632_mifare_set_key,
- .auth = &rc632_mifare_auth,
+ .fn = {
+ .power_up = &rc632_power_up,
+ .power_down = &rc632_power_down,
+ .turn_on_rf = &rc632_turn_on_rf,
+ .turn_off_rf = &rc632_turn_off_rf,
+ .transcieve = &rc632_iso14443ab_transcieve,
+ .iso14443a = {
+ .init = &rc632_iso14443a_init,
+ .transcieve_sf = &rc632_iso14443a_transcieve_sf,
+ .transcieve_acf = &rc632_iso14443a_transcieve_acf,
+ },
+ .iso14443b = {
+ .init = &rc632_iso14443b_init,
+ },
+ .iso15693 = {
+ .init = &rc632_iso15693_init,
+ },
+ .mifare_classic = {
+ .setkey = &rc632_mifare_set_key,
+ .auth = &rc632_mifare_auth,
+ },
},
},
};
-
-
int
rfid_layer2_transcieve(struct rfid_layer2_handle *ph,
+ enum rfid_frametype frametype,
const unsigned char *tx_buf, unsigned int len,
unsigned char *rx_buf, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags)
{
- return ph->l2->fn.transcieve(ph, tx_buf, len, rx_buf, rx_len,
- timeout, flags);
+ return ph->l2->fn.transcieve(ph, frametype, tx_buf, len, rx_buf,
+ rx_len, timeout, flags);
}
int rfid_layer2_fini(struct rfid_layer2_handle *ph)
/* Transmit a regular frame */
static int
iso14443a_transcieve(struct rfid_layer2_handle *handle,
+ enum rfid_frametype frametype,
const unsigned char *tx_buf, unsigned int tx_len,
unsigned char *rx_buf, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags)
{
- return handle->rh->reader->transcieve(handle->rh, tx_buf, tx_len,
- rx_buf, rx_len, timeout, flags);
+ return handle->rh->reader->transcieve(handle->rh, frametype, tx_buf,
+ tx_len, rx_buf, rx_len, timeout, flags);
}
static int
}
iso14443a_code_nvb_bits(&acf.nvb, 7*8);
- ret = iso14443a_transcieve(handle, (unsigned char *)&acf, 7,
+ ret = iso14443a_transcieve(handle, RFID_14443A_FRAME_REGULAR,
+ (unsigned char *)&acf, 7,
(unsigned char *) &sak, &rx_len,
TIMEOUT, 0);
if (ret < 0)
unsigned char rx_buf[10];
unsigned int rx_len = sizeof(rx_buf);
- ret = iso14443a_transcieve(handle, tx_buf, sizeof(tx_buf),
+ ret = iso14443a_transcieve(handle, RFID_14443A_FRAME_REGULAR,
+ tx_buf, sizeof(tx_buf),
rx_buf, &rx_len, 1000 /* 1ms */, 0);
if (ret < 0) {
/* "error" case: we don't get somethng back from the card */
if (is_wup)
reqb[2] |= 0x08;
- ret = h->rh->reader->transcieve(h->rh, reqb, sizeof(reqb),
+ ret = h->rh->reader->transcieve(h->rh, RFID_14443B_FRAME_REGULAR,
+ reqb, sizeof(reqb),
(unsigned char *)&atqb,
&atqb_len, ATQB_TIMEOUT, 0);
h->priv.iso14443b.state = ISO14443B_STATE_REQB_SENT;
attrib->param3.protocol_type = 0x1;
*rx_len = *rx_len + 1;
- ret = h->rh->reader->transcieve(h->rh, (unsigned char *) attrib,
+ ret = h->rh->reader->transcieve(h->rh, RFID_14443B_FRAME_REGULAR,
+ (unsigned char *) attrib,
sizeof(*attrib)+inf_len,
rx_buf, rx_len, h->priv.iso14443b.fwt,
0);
hltb[0] = 0x50;
memcpy(hltb+1, h->uid, 4);
- ret = h->rh->reader->transcieve(h->rh, hltb, 5,
+ ret = h->rh->reader->transcieve(h->rh, RFID_14443B_FRAME_REGULAR,
+ hltb, 5,
hltb_resp, &hltb_len,
h->priv.iso14443b.fwt, 0);
h->priv.iso14443b.state = ISO14443B_STATE_HLTB_SENT;
static int
iso14443b_transcieve(struct rfid_layer2_handle *handle,
+ enum rfid_frametype frametype,
const unsigned char *tx_buf, unsigned int tx_len,
unsigned char *rx_buf, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags)
{
DEBUGP("transcieving %u bytes, expecting max %u\n", tx_len, *rx_len);
- return handle->rh->reader->transcieve(handle->rh, tx_buf, tx_len,
+ return handle->rh->reader->transcieve(handle->rh, frametype,
+ tx_buf, tx_len,
rx_buf, rx_len, timeout, flags);
}
.fini = &iso14443b_fini,
},
};
-
#include <rfid/rfid.h>
#include <rfid/rfid_protocol.h>
#include <rfid/rfid_layer2.h>
-//#include <rfid/rfid_layer2_iso14443b.h>
+#include <rfid/rfid_protocol_mifare_classic.h>
-//#include <rfid/rfid_asic.h>
#include <rfid/rfid_reader.h>
#include "rfid_iso14443_common.h"
#define MIFARE_UL_CMD_READ 0x30
/* FIXME */
-#define MIFARE_UL_READ_FWT 100
-#define MIFARE_UL_WRITE_FWT 100
+#define MIFARE_CL_READ_FWT 100
+#define MIFARE_CL_WRITE_FWT 100
static int
mfcl_read(struct rfid_protocol_handle *ph, unsigned int page,
unsigned char tx[2];
int ret;
- if (page > 7)
+ if (page > MIFARE_CL_PAGE_MAX)
return -EINVAL;
- tx[0] = MIFARE_UL_CMD_READ;
+ tx[0] = MIFARE_CL_CMD_READ;
tx[1] = page & 0xff;
- ret = ph->l2h->l2->fn.transcieve(ph->l2h, tx, sizeof(tx), rx_buf,
- &real_rx_len, MIFARE_UL_READ_FWT, 0);
+ ret = ph->l2h->l2->fn.transcieve(ph->l2h, RFID_MIFARE_FRAME, tx,
+ sizeof(tx), rx_buf, &real_rx_len,
+ MIFARE_CL_READ_FWT, 0);
if (ret < 0)
return ret;
unsigned char *tx_data, unsigned int tx_len)
{
unsigned int i;
- unsigned char tx[6];
+ unsigned char tx[18];
unsigned char rx[1];
unsigned int rx_len;
int ret;
- if (tx_len != 4 || page > 7)
+ if (tx_len != 16 || page > MIFARE_CL_PAGE_MAX)
return -EINVAL;
- tx[0] = MIFARE_UL_CMD_WRITE;
+ tx[0] = MIFARE_CL_CMD_WRITE16;
tx[1] = page & 0xff;
- for (i = 0; i < 4; i++)
- tx[2+i] = tx_data[i];
+ memcpy(tx+2, tx_data, 16);
- ret = ph->l2h->l2->fn.transcieve(ph->l2h, tx, sizeof(tx), rx,
- &rx_len, MIFARE_UL_WRITE_FWT, 0);
+ ret = ph->l2h->l2->fn.transcieve(ph->l2h, RFID_MIFARE_FRAME, tx,
+ sizeof(tx), rx, &rx_len,
+ MIFARE_CL_WRITE_FWT, 0);
- /* FIXME:look at RX, check for ACK/NAK */
+ if (ret < 0)
+ return ret;
+
+ if (rx[0] != MIFARE_UL_RESP_ACK)
+ return -EIO;
return ret;
}
tx[0] = MIFARE_UL_CMD_READ;
tx[1] = page & 0xff;
- ret = ph->l2h->l2->fn.transcieve(ph->l2h, tx, sizeof(tx), rx_buf,
+ ret = ph->l2h->l2->fn.transcieve(ph->l2h, RFID_14443A_FRAME_REGULAR,
+ tx, sizeof(tx), rx_buf,
&real_rx_len, MIFARE_UL_READ_FWT, 0);
if (ret < 0)
unsigned int rx_len = sizeof(rx);
int ret;
-#if 0
if (tx_len != 4 || page > MIFARE_UL_PAGE_MAX)
return -EINVAL;
-#endif
tx[0] = MIFARE_UL_CMD_WRITE;
tx[1] = page & 0xff;
for (i = 0; i < 4; i++)
tx[2+i] = tx_data[i];
- ret = ph->l2h->l2->fn.transcieve(ph->l2h, tx, sizeof(tx), rx,
- &rx_len, MIFARE_UL_WRITE_FWT, 0);
+ ret = ph->l2h->l2->fn.transcieve(ph->l2h, RFID_14443A_FRAME_REGULAR,
+ tx, sizeof(tx), rx, &rx_len,
+ MIFARE_UL_WRITE_FWT, 0);
if (ret < 0)
return ret;
rats[1] = (h->priv.tcl.cid & 0x0f) | ((fsdi << 4) & 0xf0);
/* transcieve (with CRC) */
- ret = h->l2h->l2->fn.transcieve(h->l2h, rats, 2, h->priv.tcl.ats,
+ ret = h->l2h->l2->fn.transcieve(h->l2h, RFID_14443A_FRAME_REGULAR,
+ rats, 2, h->priv.tcl.ats,
&h->priv.tcl.ats_len, activation_fwt(h),
TCL_TRANSP_F_TX_CRC);
if (ret < 0) {
if (ret < 0)
return ret;
- ret = h->l2h->l2->fn.transcieve(h->l2h, frame, prlg_len, rx,
+ ret = h->l2h->l2->fn.transcieve(h->l2h, RFID_14443A_FRAME_REGULAR,
+ frame, prlg_len, rx,
&rx_len, deactivation_fwt(h),
TCL_TRANSP_F_TX_CRC);
if (ret < 0) {
_timeout = th->fwt;
do_tx:
- ret = h->l2h->l2->fn.transcieve(h->l2h, _tx, _tx_len,
+ ret = h->l2h->l2->fn.transcieve(h->l2h, RFID_14443A_FRAME_REGULAR,
+ _tx, _tx_len,
rx_buf, rx_len, _timeout, 0);
DEBUGP("l2 transcieve finished\n");
if (ret < 0)
int
rfid_reader_transcieve(struct rfid_reader_handle *rh,
+ enum rfid_frametype frametype,
const unsigned char *tx_buf, unsigned int len,
unsigned char *rx_buf, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags)
{
- return rh->reader->transcieve(rh, tx_buf, len, rx_buf, rx_len,
- timeout, flags);
+ return rh->reader->transcieve(rh, frametype, tx_buf, len, rx_buf,
+ rx_len, timeout, flags);
}
void
#endif
static int cm5121_transcieve(struct rfid_reader_handle *rh,
+ enum rfid_frametype frametype,
const unsigned char *tx_data, unsigned int tx_len,
unsigned char *rx_data, unsigned int *rx_len,
u_int64_t timeout, unsigned int flags)
{
- return rh->ah->asic->priv.rc632.fn.transcieve(rh->ah, tx_data,
- tx_len, rx_data,
- rx_len, timeout,
- flags);
+ return rh->ah->asic->priv.rc632.fn.transcieve(rh->ah, frametype,
+ tx_data, tx_len, rx_data,
+ rx_len, timeout, flags);
}
static int cm5121_transcieve_sf(struct rfid_reader_handle *rh,
return rh->ah->asic->priv.rc632.fn.iso15693.init(rh->ah);
}
+static int
+cm5121_mifare_setkey(struct rfid_reader_handle *rh, const u_int8_t *key)
+{
+ return rh->ah->asic->priv.rc632.fn.mifare_classic.setkey(rh->ah, key);
+}
+
static int
cm5121_mifare_auth(struct rfid_reader_handle *rh, u_int8_t cmd,
u_int32_t serno, u_int8_t block)
.init = &cm5121_14443b_init,
},
.mifare_classic = {
+ .setkey = &cm5121_mifare_setkey,
.auth = &cm5121_mifare_auth,
},
};
projects / librfid / commitdiff