X-Git-Url: http://git.rot13.org/?a=blobdiff_plain;f=src%2Frfid_reader_openpcd.c;h=d81a7ddd3e2365297daa0ddb56297e135c76ef40;hb=893a580c6f1c7f1cc50d9bd1acc51c9fd6307a17;hp=51852f063dcc5cb2e5fa0684af0cc28f3756441a;hpb=2f426580fa990c1e190d09f9d6a4a7fc9b6d25c3;p=librfid diff --git a/src/rfid_reader_openpcd.c b/src/rfid_reader_openpcd.c index 51852f0..d81a7dd 100644 --- a/src/rfid_reader_openpcd.c +++ b/src/rfid_reader_openpcd.c @@ -22,28 +22,27 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ -//#define DEBUG - #include #include #include #include -#include - #include #include #include #include #include +#include +#include + +#include "rfid_reader_rc632_common.h" /* FIXME */ #include "rc632.h" - #define SENDBUF_LEN (256+4+10) /* 256bytes max FSD/FSC, plus 4 bytes header, plus 10 bytes reserve */ #define RECVBUF_LEN SENDBUF_LEN @@ -53,6 +52,21 @@ static char rcv_buf[RECVBUF_LEN]; static struct openpcd_hdr *snd_hdr; static struct openpcd_hdr *rcv_hdr; +#ifndef LIBRFID_FIRMWARE + +#ifdef __MINGW32__ +#include "libusb_dyn.h" +#else /*__MINGW32__*/ +#include +#endif/*__MINGW32__*/ + +#ifdef DEBUG_REGISTER +#define DEBUGRC DEBUGPC +#define DEBUGR DEBUGP +#else +#define DEBUGRC(x, args ...) do {} while(0) +#define DEBUGR(x, args ...) do {} while(0) +#endif static struct usb_device *dev; static struct usb_dev_handle *hdl; @@ -72,7 +86,7 @@ static int openpcd_send_command(u_int8_t cmd, u_int8_t reg, u_int8_t val, cur = sizeof(*snd_hdr) + len; - return usb_bulk_write(hdl, OPENPCD_OUT_EP, (char *)snd_hdr, cur, 0); + return usb_bulk_write(hdl, OPENPCD_OUT_EP, (char *)snd_hdr, cur, 1000); } static int openpcd_recv_reply(void) @@ -92,7 +106,7 @@ static int openpcd_xcv(u_int8_t cmd, u_int8_t reg, u_int8_t val, ret = openpcd_send_command(cmd, reg, val, len, data); if (ret < 0) return ret; - if (ret < sizeof(sizeof(struct openpcd_hdr))) + if (ret < sizeof(struct openpcd_hdr)) return -EINVAL; return openpcd_recv_reply(); @@ -112,15 +126,12 @@ static struct usb_device *find_opcd_device(void) { struct usb_bus *bus; - for (bus = usb_busses; bus; bus = bus->next) { + for (bus = usb_get_busses(); bus; bus = bus->next) { struct usb_device *dev; for (dev = bus->devices; dev; dev = dev->next) { int i; - printf("usb: %4x:%4x\n", dev->descriptor.idVendor, - dev->descriptor.idProduct); for (i = 0; i < ARRAY_SIZE(opcd_usb_ids); i++) { const struct usb_id *id = &opcd_usb_ids[i]; - printf("%x:%x\n", id->vid, id->pid); if (dev->descriptor.idVendor == id->vid && dev->descriptor.idProduct == id->pid) return dev; @@ -130,18 +141,20 @@ static struct usb_device *find_opcd_device(void) return NULL; } +/* RC632 access primitives for librfid inside reader firmware */ + static int openpcd_reg_write(struct rfid_asic_transport_handle *rath, unsigned char reg, unsigned char value) { int ret; - DEBUGP("reg=0x%02x, val=%02x: ", reg, value); + DEBUGR("reg=0x%02x, val=%02x: ", reg, value); ret = openpcd_xcv(OPENPCD_CMD_WRITE_REG, reg, value, 0, NULL); if (ret < 0) - DEBUGPC("ERROR sending command\n"); + DEBUGRC("ERROR sending command\n"); else - DEBUGPC("OK\n"); + DEBUGRC("OK\n"); return ret; } @@ -152,21 +165,21 @@ static int openpcd_reg_read(struct rfid_asic_transport_handle *rath, { int ret; - DEBUGP("reg=0x%02x, ", reg); + DEBUGR("reg=0x%02x, ", reg); ret = openpcd_xcv(OPENPCD_CMD_READ_REG, reg, 0, 0, NULL); if (ret < 0) { - DEBUGPC("ERROR sending command\n"); + DEBUGRC("ERROR sending command\n"); return ret; } if (ret < sizeof(struct openpcd_hdr)) { - DEBUGPC("ERROR: short packet\n"); + DEBUGRC("ERROR: short packet\n"); return ret; } *value = rcv_hdr->val; - DEBUGPC("val=%02x: OK\n", *value); + DEBUGRC("val=%02x: OK\n", *value); return ret; } @@ -177,17 +190,17 @@ static int openpcd_fifo_read(struct rfid_asic_transport_handle *rath, { int ret; - DEBUGP(" "); + DEBUGR(" "); ret = openpcd_xcv(OPENPCD_CMD_READ_FIFO, 0x00, num_bytes, 0, NULL); if (ret < 0) { - DEBUGPC("ERROR sending command\n"); + DEBUGRC("ERROR sending command\n"); return ret; } - DEBUGPC("ret = %d\n", ret); + DEBUGRC("ret = %d\n", ret); memcpy(buf, rcv_hdr->data, ret - sizeof(struct openpcd_hdr)); - DEBUGPC("len=%d val=%s: OK\n", ret - sizeof(struct openpcd_hdr), + DEBUGRC("len=%d val=%s: OK\n", ret - sizeof(struct openpcd_hdr), rfid_hexdump(rcv_hdr->data, ret - sizeof(struct openpcd_hdr))); return ret; @@ -200,108 +213,133 @@ static int openpcd_fifo_write(struct rfid_asic_transport_handle *rath, { int ret; - DEBUGP("len=%u, data=%s\n", len, rfid_hexdump(bytes, len)); + DEBUGR("len=%u, data=%s\n", len, rfid_hexdump(bytes, len)); ret = openpcd_xcv(OPENPCD_CMD_WRITE_FIFO, 0, 0, len, bytes); return ret; } -static int openpcd_transceive(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.transceive(rh->ah, frametype, - tx_data, tx_len, - rx_data, rx_len, - timeout, flags); -} +const struct rfid_asic_transport openpcd_rat = { + .name = "OpenPCD Dumb USB Protocol", + .priv.rc632 = { + .fn = { + .reg_write = &openpcd_reg_write, + .reg_read = &openpcd_reg_read, + .fifo_write = &openpcd_fifo_write, + .fifo_read = &openpcd_fifo_read, + }, + }, +}; -static int openpcd_transceive_sf(struct rfid_reader_handle *rh, - unsigned char cmd, struct iso14443a_atqa *atqa) +static int openpcd_get_api_version(struct rfid_reader_handle *rh, u_int8_t *version) { - return rh->ah->asic->priv.rc632.fn.iso14443a.transceive_sf(rh->ah, - cmd, - atqa); -} + int ret; + + // preset version result to zero + rcv_hdr->val=0; + + ret = openpcd_xcv(OPENPCD_CMD_GET_API_VERSION, 0, 0, 0, NULL); + if (ret < 0) { + DEBUGPC("ERROR sending command [%i]\n", ret); + return ret; + } -static int -openpcd_transceive_acf(struct rfid_reader_handle *rh, - struct iso14443a_anticol_cmd *cmd, - unsigned int *bit_of_col) -{ - return rh->ah->asic->priv.rc632.fn.iso14443a.transceive_acf(rh->ah, - cmd, bit_of_col); + if (ret < sizeof(struct openpcd_hdr)) { + DEBUGPC("ERROR: short packet [%i]\n", ret); + return -EINVAL; + } + + *version = rcv_hdr->val; + + return ret; } -static int -openpcd_14443a_init(struct rfid_reader_handle *rh) +static int openpcd_get_environment(struct rfid_reader_handle *rh, + unsigned char num_bytes, + unsigned char *buf) { - return rh->ah->asic->priv.rc632.fn.iso14443a.init(rh->ah); + int ret; + + DEBUGP(" "); + + ret = openpcd_xcv(OPENPCD_CMD_GET_ENVIRONMENT, 0x00, num_bytes, 0, NULL); + if (ret < 0) { + DEBUGPC("ERROR sending command [%i]\n",ret); + return ret; + } + DEBUGPC("ret = %d\n", ret); + + memcpy(buf, rcv_hdr->data, ret - sizeof(struct openpcd_hdr)); + DEBUGPC("len=%d val=%s: OK\n", ret - sizeof(struct openpcd_hdr), + rfid_hexdump(rcv_hdr->data, ret - sizeof(struct openpcd_hdr))); + + return ret; } -static int -openpcd_14443a_set_speed(struct rfid_reader_handle *rh, - unsigned int tx, - unsigned int speed) +static int openpcd_set_environment(struct rfid_reader_handle *rh, + unsigned char num_bytes, + const unsigned char *buf) { - u_int8_t rate; + int ret; - DEBUGP("setting rate: "); - switch (speed) { - case RFID_14443A_SPEED_106K: - rate = 0x00; - DEBUGPC("106K\n"); - break; - case RFID_14443A_SPEED_212K: - rate = 0x01; - DEBUGPC("212K\n"); - break; - case RFID_14443A_SPEED_424K: - rate = 0x02; - DEBUGPC("424K\n"); - break; - case RFID_14443A_SPEED_848K: - rate = 0x03; - DEBUGPC("848K\n"); - break; - default: + ret = openpcd_xcv(OPENPCD_CMD_SET_ENVIRONMENT, 0, 0, num_bytes, buf); + if (ret < 0) { + DEBUGPC("ERROR sending command [%i]\n",ret); + return ret; + } + + if (ret < sizeof(struct openpcd_hdr)) { + DEBUGPC("ERROR: short packet [%i]\n", ret); return -EINVAL; - break; } - return rh->ah->asic->priv.rc632.fn.iso14443a.set_speed(rh->ah, - tx, rate); + + return rcv_hdr->val; } -static int -openpcd_14443b_init(struct rfid_reader_handle *rh) +static int openpcd_reset(struct rfid_reader_handle *rh) +{ + int ret; + + DEBUGP("reset "); + ret = openpcd_xcv(OPENPCD_CMD_RESET, 0, 0, 0, 0); + + return ret; +} + +#else +/* RC632 access primitives for librfid inside reader firmware */ + +static int openpcd_reg_write(struct rfid_asic_transport_handle *rath, + unsigned char reg, unsigned char value) { - return rh->ah->asic->priv.rc632.fn.iso14443b.init(rh->ah); + return opcd_rc632_reg_write(rath, reg, value); } -static int -openpcd_15693_init(struct rfid_reader_handle *rh) +static int openpcd_reg_read(struct rfid_asic_transport_handle *rath, + unsigned char reg, + unsigned char *value) { - return rh->ah->asic->priv.rc632.fn.iso15693.init(rh->ah); + return opcd_rc632_reg_read(rath, reg, value); } -static int -openpcd_mifare_setkey(struct rfid_reader_handle *rh, const u_int8_t *key) + +static int openpcd_fifo_read(struct rfid_asic_transport_handle *rath, + unsigned char num_bytes, + unsigned char *buf) { - return rh->ah->asic->priv.rc632.fn.mifare_classic.setkey(rh->ah, key); + return opcd_rc632_fifo_read(rath, num_bytes, buf); } -static int -openpcd_mifare_auth(struct rfid_reader_handle *rh, u_int8_t cmd, - u_int32_t serno, u_int8_t block) +static int openpcd_fifo_write(struct rfid_asic_transport_handle *rath, + unsigned char len, + const unsigned char *bytes, + unsigned char flags) { - return rh->ah->asic->priv.rc632.fn.mifare_classic.auth(rh->ah, - cmd, serno, block); + return opcd_rc632_fifo_write(rath, len, bytes, flags); } -struct rfid_asic_transport openpcd_ccid = { - .name = "OpenPCD Dumb USB Protocol", +const struct rfid_asic_transport openpcd_rat = { + .name = "OpenPCD Firmware RC632 Access", .priv.rc632 = { .fn = { .reg_write = &openpcd_reg_write, @@ -312,6 +350,27 @@ struct rfid_asic_transport openpcd_ccid = { }, }; +#endif /* LIBRFID_FIRMWARE */ + +static int openpcd_getopt(struct rfid_reader_handle *rh, int optname, + void *optval, unsigned int *optlen) +{ + int rc; + u_int8_t *val_u8 = (u_int8_t *) optval; + + switch (optname) { +#ifndef LIBRFID_FIRMWARE + case RFID_OPT_RDR_FW_VERSION: + return openpcd_get_api_version(rh, val_u8); +#endif + default: + return _rdr_rc632_getopt(rh, optname, optval, optlen); + } + + return 0; +} + + static struct rfid_reader_handle * openpcd_open(void *data) { @@ -321,6 +380,7 @@ openpcd_open(void *data) snd_hdr = (struct openpcd_hdr *)snd_buf; rcv_hdr = (struct openpcd_hdr *)rcv_buf; +#ifndef LIBRFID_FIRMWARE usb_init(); if (usb_find_busses() < 0) return NULL; @@ -339,23 +399,31 @@ openpcd_open(void *data) return NULL; } + if(usb_set_configuration(hdl, 1 ) < 0) + { + DEBUGP("setting config failed\n"); + usb_close( hdl ); + return NULL; + } + if (usb_claim_interface(hdl, 0) < 0) { DEBUGP("Can't claim interface\n"); usb_close(hdl); return NULL; } +#endif - rh = malloc(sizeof(*rh)); + rh = malloc_reader_handle(sizeof(*rh)); if (!rh) return NULL; memset(rh, 0, sizeof(*rh)); - rath = malloc(sizeof(*rath)); + rath = malloc_rat_handle(sizeof(*rath)); if (!rath) goto out_rh; memset(rath, 0, sizeof(*rath)); - rath->rat = &openpcd_ccid; + rath->rat = &openpcd_rat; rh->reader = &rfid_reader_openpcd; rh->ah = rc632_open(rath); @@ -366,9 +434,9 @@ openpcd_open(void *data) return rh; out_rath: - free(rath); + free_rat_handle(rath); out_rh: - free(rh); + free_reader_handle(rh); return NULL; } @@ -379,31 +447,45 @@ openpcd_close(struct rfid_reader_handle *rh) struct rfid_asic_transport_handle *rath = rh->ah->rath; rc632_close(rh->ah); - free(rath); - free(rh); + free_rat_handle(rath); + free_reader_handle(rh); +#ifndef LIBRFID_FIRMWARE usb_close(hdl); +#endif } -struct rfid_reader rfid_reader_openpcd = { +const struct rfid_reader rfid_reader_openpcd = { .name = "OpenPCD RFID Reader", .id = RFID_READER_OPENPCD, .open = &openpcd_open, .close = &openpcd_close, - .transceive = &openpcd_transceive, + .getopt = &openpcd_getopt, +#ifndef LIBRFID_FIRMWARE + .reset = &openpcd_reset, +#endif + .setopt = &_rdr_rc632_setopt, + .init = &_rdr_rc632_l2_init, + .transceive = &_rdr_rc632_transceive, + .l2_supported = (1 << RFID_LAYER2_ISO14443A) | + (1 << RFID_LAYER2_ISO14443B) | + (1 << RFID_LAYER2_ISO15693), + .proto_supported = (1 << RFID_PROTOCOL_TCL) | + (1 << RFID_PROTOCOL_MIFARE_UL) | + (1 << RFID_PROTOCOL_MIFARE_CLASSIC), .iso14443a = { - .init = &openpcd_14443a_init, - .transceive_sf = &openpcd_transceive_sf, - .transceive_acf = &openpcd_transceive_acf, + .transceive_sf = &_rdr_rc632_transceive_sf, + .transceive_acf = &_rdr_rc632_transceive_acf, .speed = RFID_14443A_SPEED_106K | RFID_14443A_SPEED_212K | RFID_14443A_SPEED_424K, //| RFID_14443A_SPEED_848K, - .set_speed = &openpcd_14443a_set_speed, + .set_speed = &_rdr_rc632_14443a_set_speed, }, - .iso14443b = { - .init = &openpcd_14443b_init, + .iso15693 = { + .transceive_ac = &_rdr_rc632_iso15693_transceive_ac, }, .mifare_classic = { - .setkey = &openpcd_mifare_setkey, - .auth = &openpcd_mifare_auth, + .setkey = &_rdr_rc632_mifare_setkey, + .setkey_ee = &_rdr_rc632_mifare_setkey_ee, + .auth = &_rdr_rc632_mifare_auth, }, };