make "frametype" a parameter of transcieve functions

git-svn-id: https://svn.gnumonks.org/trunk/librfid@1559 e0336214-984f-0b4b-a45f-81c69e1f0ede

16 files changed, 253 insertions, 98 deletions

diff --git a/include/rfid/rfid.h b/include/rfid/rfid.h
index bebb42a..f9d36c9 100644
--- a/include/rfid/rfid.h
+++ b/include/rfid/rfid.h
@@ -3,6 +3,13 @@
 
 #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)
diff --git a/include/rfid/rfid_asic.h b/include/rfid/rfid_asic.h
index e336d01..6511615 100644
--- a/include/rfid/rfid_asic.h
+++ b/include/rfid/rfid_asic.h
@@ -1,6 +1,8 @@
 #ifndef _RFID_ASIC_H
 #define _RFID_ASIC_H
 
+enum rfid_frametype;
+
 #include <rfid/rfid_asic_rc632.h>
 
 struct rfid_asic_transport {
diff --git a/include/rfid/rfid_asic_rc632.h b/include/rfid/rfid_asic_rc632.h
index 7a984ff..a84f792 100644
--- a/include/rfid/rfid_asic_rc632.h
+++ b/include/rfid/rfid_asic_rc632.h
@@ -3,6 +3,8 @@
 
 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,
@@ -33,6 +35,7 @@ struct rfid_asic_rc632 {
 		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,
@@ -55,7 +58,8 @@ struct rfid_asic_rc632 {
 			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;
diff --git a/include/rfid/rfid_layer2.h b/include/rfid/rfid_layer2.h
index c87578b..f6d9117 100644
--- a/include/rfid/rfid_layer2.h
+++ b/include/rfid/rfid_layer2.h
@@ -4,6 +4,8 @@
 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>
@@ -17,6 +19,7 @@ struct rfid_layer2 {
 		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,
@@ -50,6 +53,7 @@ struct rfid_layer2_handle *rfid_layer2_init(struct rfid_reader_handle *rh,
 					    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);
diff --git a/include/rfid/rfid_protocol_mifare_classic.h b/include/rfid/rfid_protocol_mifare_classic.h
index 01066f4..64ef11e 100644
--- a/include/rfid/rfid_protocol_mifare_classic.h
+++ b/include/rfid/rfid_protocol_mifare_classic.h
@@ -5,7 +5,16 @@ extern struct rfid_protocol rfid_protocol_mfcl;
 #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
diff --git a/include/rfid/rfid_reader.h b/include/rfid/rfid_reader.h
index 0acd532..501119b 100644
--- a/include/rfid/rfid_reader.h
+++ b/include/rfid/rfid_reader.h
@@ -10,6 +10,7 @@ struct rfid_reader {
 	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);
@@ -61,4 +62,10 @@ struct rfid_reader_handle {
 	} 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
diff --git a/openct-escape.c b/openct-escape.c
index b488610..628aded 100644
--- a/openct-escape.c
+++ b/openct-escape.c
@@ -237,12 +237,13 @@ iso7816_read_ef(u_int16_t fid, unsigned char *buf, unsigned int *len)
 	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
@@ -259,7 +260,7 @@ mifare_ulight_blank(struct rfid_protocol_handle *ph)
 	return 0;
 }
 
-int
+static int
 mifare_ulight_read(struct rfid_protocol_handle *ph)
 {
 	unsigned char buf[20];
@@ -277,6 +278,26 @@ mifare_ulight_read(struct rfid_protocol_handle *ph)
 	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;
@@ -286,9 +307,9 @@ int main(int argc, char **argv)
 	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);
@@ -298,8 +319,8 @@ int main(int argc, char **argv)
 		/* 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);
@@ -312,19 +333,25 @@ int main(int argc, char **argv)
 	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;
 	}
 
diff --git a/rfid_asic_rc632.c b/rfid_asic_rc632.c
index 36cca71..eeb6d89 100644
--- a/rfid_asic_rc632.c
+++ b/rfid_asic_rc632.c
@@ -43,7 +43,7 @@
 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)
@@ -51,7 +51,7 @@ rc632_reg_write(struct rfid_asic_handle *handle,
 	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)
@@ -59,7 +59,7 @@ rc632_reg_read(struct rfid_asic_handle *handle,
 	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,
@@ -69,7 +69,7 @@ rc632_fifo_write(struct rfid_asic_handle *handle,
 							   len, buf, flags);
 }
 
-int 
+static int 
 rc632_fifo_read(struct rfid_asic_handle *handle,
 		u_int8_t len,
 		u_int8_t *buf)
@@ -78,7 +78,7 @@ rc632_fifo_read(struct rfid_asic_handle *handle,
 }
 
 
-int
+static int
 rc632_set_bits(struct rfid_asic_handle *handle, 
 		u_int8_t reg,
 		u_int8_t val)
@@ -97,7 +97,7 @@ rc632_set_bits(struct rfid_asic_handle *handle,
 	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)
@@ -118,23 +118,21 @@ rc632_clear_bits(struct rfid_asic_handle *handle,
 	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();
@@ -142,7 +140,7 @@ rc632_power_up(struct rfid_asic_handle *handle)
 				RC632_CONTROL_POWERDOWN);
 }
 
-int
+static int
 rc632_power_down(struct rfid_asic_handle *handle)
 {
 	return rc632_set_bits(handle, RC632_REG_CONTROL,
@@ -151,7 +149,7 @@ rc632_power_down(struct rfid_asic_handle *handle)
 
 /* 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;
@@ -182,7 +180,7 @@ rc632_wait_idle(struct rfid_asic_handle *handle, u_int64_t timeout)
 	return 0;
 }
 
-int
+static int
 rc632_transmit(struct rfid_asic_handle *handle,
 		const u_int8_t *buf,
 		u_int8_t len,
@@ -208,7 +206,7 @@ tcl_toggle_pcb(struct rfid_asic_handle *handle)
 	return 0;
 }
 
-int
+static int
 rc632_transcieve(struct rfid_asic_handle *handle,
 		 const u_int8_t *tx_buf,
 		 u_int8_t tx_len,
@@ -252,7 +250,7 @@ rc632_transcieve(struct rfid_asic_handle *handle,
 	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];
@@ -281,7 +279,7 @@ rc632_read_eeprom(struct rfid_asic_handle *handle)
 	return ret;
 }
 
-int
+static int
 rc632_calc_crc16_from(struct rfid_asic_handle *handle)
 {
 	u_int8_t sndbuf[2] = { 0x01, 0x02 };
@@ -618,17 +616,29 @@ rc632_iso14443a_transcieve_sf(struct rfid_asic_handle *handle,
 
 /* 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 |
@@ -636,8 +646,8 @@ rc632_iso14443a_transcieve(struct rfid_asic_handle *handle,
 				 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;
 
@@ -1117,6 +1127,7 @@ static int
 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);
@@ -1135,6 +1146,13 @@ rc632_mifare_set_key(struct rfid_asic_handle *h, const u_int8_t *key)
 	if (ret < 0)
 		return ret;
 
+	ret = rc632_reg_read(h, RC632_REG_ERROR_FLAG, &reg);
+	if (ret < 0)
+		return ret;
+
+	if (reg & RC632_ERR_FLAG_KEY_ERR)
+		return -EINVAL;
+
 	return 0;
 }
 
@@ -1152,10 +1170,20 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno,
 	/* 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;
 
@@ -1168,9 +1196,15 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno,
 	if (ret < 0)
 		return ret;
 
-	/* Clear Rx/Tx CRC */
+	ret = rc632_reg_read(h, RC632_REG_SECONDARY_STATUS, &reg);
+	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;
 
@@ -1179,10 +1213,14 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno,
 	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, &reg);
@@ -1196,31 +1234,65 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno,
 
 }
 
+/* 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,
+			},
 		},
 	},
 };
-
-
diff --git a/rfid_layer2.c b/rfid_layer2.c
index ef59bad..c1ab6a6 100644
--- a/rfid_layer2.c
+++ b/rfid_layer2.c
@@ -46,12 +46,13 @@ rfid_layer2_open(struct rfid_layer2_handle *ph)
 
 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)
diff --git a/rfid_layer2_iso14443a.c b/rfid_layer2_iso14443a.c
index 7d7c377..d93f917 100644
--- a/rfid_layer2_iso14443a.c
+++ b/rfid_layer2_iso14443a.c
@@ -55,12 +55,13 @@ iso14443a_transcieve_acf(struct rfid_layer2_handle *handle,
 /* 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 
@@ -155,7 +156,8 @@ cascade:
 	}
 
 	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)
@@ -238,7 +240,8 @@ iso14443a_hlta(struct rfid_layer2_handle *handle)
 	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 */
diff --git a/rfid_layer2_iso14443b.c b/rfid_layer2_iso14443b.c
index c5ff592..f874071 100644
--- a/rfid_layer2_iso14443b.c
+++ b/rfid_layer2_iso14443b.c
@@ -114,7 +114,8 @@ send_reqb(struct rfid_layer2_handle *h, unsigned char afi,
 		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;
@@ -199,7 +200,8 @@ transcieve_attrib(struct rfid_layer2_handle *h, const unsigned char *inf,
 		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);
@@ -242,7 +244,8 @@ iso14443b_hltb(struct rfid_layer2_handle *h)
 	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;
@@ -317,12 +320,14 @@ iso14443b_fini(struct rfid_layer2_handle *handle)
 
 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);
 }
 
@@ -337,4 +342,3 @@ struct rfid_layer2 rfid_layer2_iso14443b = {
 		.fini 		= &iso14443b_fini,
 	},
 };
-
diff --git a/rfid_proto_mifare_classic.c b/rfid_proto_mifare_classic.c
index 474f554..10de288 100644
--- a/rfid_proto_mifare_classic.c
+++ b/rfid_proto_mifare_classic.c
@@ -28,9 +28,8 @@
 #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"
@@ -40,8 +39,8 @@
 #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,
@@ -52,14 +51,15 @@ 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;
@@ -77,24 +77,28 @@ mfcl_write(struct rfid_protocol_handle *ph, unsigned int page,
 	   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;
 }
diff --git a/rfid_proto_mifare_ul.c b/rfid_proto_mifare_ul.c
index adac9cc..9e5363f 100644
--- a/rfid_proto_mifare_ul.c
+++ b/rfid_proto_mifare_ul.c
@@ -52,7 +52,8 @@ mful_read(struct rfid_protocol_handle *ph, unsigned int page,
 	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)
@@ -76,10 +77,8 @@ mful_write(struct rfid_protocol_handle *ph, unsigned int page,
 	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;
@@ -87,8 +86,9 @@ mful_write(struct rfid_protocol_handle *ph, unsigned int page,
 	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;
diff --git a/rfid_proto_tcl.c b/rfid_proto_tcl.c
index 248eea5..8590fd4 100644
--- a/rfid_proto_tcl.c
+++ b/rfid_proto_tcl.c
@@ -165,7 +165,8 @@ tcl_request_ats(struct rfid_protocol_handle *h)
 	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) {
@@ -432,7 +433,8 @@ tcl_deselect(struct rfid_protocol_handle *h)
 	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) {
@@ -494,7 +496,8 @@ tcl_transcieve(struct rfid_protocol_handle *h,
 	_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)
diff --git a/rfid_reader.c b/rfid_reader.c
index 2a34db8..9e46a29 100644
--- a/rfid_reader.c
+++ b/rfid_reader.c
@@ -40,12 +40,13 @@ rfid_reader_open(void *data, unsigned int id)
 
 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
diff --git a/rfid_reader_cm5121.c b/rfid_reader_cm5121.c
index e1fc859..0a72836 100644
--- a/rfid_reader_cm5121.c
+++ b/rfid_reader_cm5121.c
@@ -180,14 +180,14 @@ static int TestFIFO(struct rc632_handle *handle)
 #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,
@@ -226,6 +226,12 @@ cm5121_15693_init(struct rfid_reader_handle *rh)
 }
 
 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)
 {
@@ -321,6 +327,7 @@ struct rfid_reader rfid_reader_cm5121 = {
 		.init = &cm5121_14443b_init,
 	},
 	.mifare_classic = {
+		.setkey = &cm5121_mifare_setkey,
 		.auth = &cm5121_mifare_auth,
 	},
 };