added win32 support for MINGW32-compiler/cross-compiler

[librfid] / src / rfid_reader_openpcd.c

diff --git a/src/rfid_reader_openpcd.c b/src/rfid_reader_openpcd.c
index b964165..866bef4 100644 (file)
--- a/src/rfid_reader_openpcd.c
+++ b/src/rfid_reader_openpcd.c
@@ -32,18 +32,18 @@
 #include <string.h>
 #include <errno.h>
 
-#include <usb.h>
 
 #include <librfid/rfid.h>
 #include <librfid/rfid_reader.h>
 #include <librfid/rfid_asic.h>
 #include <librfid/rfid_asic_rc632.h>
 #include <librfid/rfid_reader_openpcd.h>
+#include <librfid/rfid_layer2.h>
+#include <librfid/rfid_protocol.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
@@ -54,6 +54,14 @@ static struct openpcd_hdr *snd_hdr;
 static struct openpcd_hdr *rcv_hdr;
 
 
+#ifndef LIBRFID_FIRMWARE
+
+#ifdef  __MINGW32__
+#include "libusb_dyn.h"
+#else /*__MINGW32__*/
+#include <usb.h>
+#endif/*__MINGW32__*/
+
 static struct usb_device *dev;
 static struct usb_dev_handle *hdl;
 
@@ -92,7 +100,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();
@@ -119,9 +127,7 @@ static struct usb_device *find_opcd_device(void)
                        for (i = 0; i < ARRAY_SIZE(opcd_usb_ids); i++) {
                                const struct usb_id *id = &opcd_usb_ids[i];
                                if (dev->descriptor.idVendor == id->vid &&
-                                   dev->descriptor.idProduct == id->pid &&
-                                   dev->descriptor.bNumConfigurations == 1 &&
-                                   dev->config->iConfiguration == 0)
+                                   dev->descriptor.idProduct == id->pid)
                                        return dev;
                        }
                }
@@ -129,6 +135,8 @@ 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)
 {
@@ -205,6 +213,64 @@ static int openpcd_fifo_write(struct rfid_asic_transport_handle *rath,
        return ret;
 }
 
+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,
+               },
+       },
+};
+
+#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 opcd_rc632_reg_write(rath, reg, value);
+}
+
+static int openpcd_reg_read(struct rfid_asic_transport_handle *rath,
+                           unsigned char reg,
+                           unsigned char *value)
+{
+       return opcd_rc632_reg_read(rath, reg, value);
+}
+
+
+static int openpcd_fifo_read(struct rfid_asic_transport_handle *rath,
+                            unsigned char num_bytes,
+                            unsigned char *buf)
+{
+       return opcd_rc632_fifo_read(rath, num_bytes, buf);
+}
+
+static int openpcd_fifo_write(struct rfid_asic_transport_handle *rath,
+                            unsigned char len,
+                            const unsigned char *bytes,
+                            unsigned char flags)
+{
+       return opcd_rc632_fifo_write(rath, len, bytes, flags);
+}
+
+const struct rfid_asic_transport openpcd_rat = {
+       .name = "OpenPCD Firmware RC632 Access",
+       .priv.rc632 = {
+               .fn = {
+                       .reg_write      = &openpcd_reg_write,
+                       .reg_read       = &openpcd_reg_read,
+                       .fifo_write     = &openpcd_fifo_write,
+                       .fifo_read      = &openpcd_fifo_read,
+               },
+       },
+};
+
+#endif /* LIBRFID_FIRMWARE */
+
 static int openpcd_transceive(struct rfid_reader_handle *rh,
                             enum rfid_frametype frametype,
                             const unsigned char *tx_data, unsigned int tx_len,
@@ -299,18 +365,6 @@ openpcd_mifare_auth(struct rfid_reader_handle *rh, u_int8_t cmd,
                                                        cmd, serno, block);
 }
 
-struct rfid_asic_transport openpcd_ccid = {
-       .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 struct rfid_reader_handle *
 openpcd_open(void *data)
 {
@@ -320,10 +374,11 @@ 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())
+       if (usb_find_busses() < 0)
                return NULL;
-       if (!usb_find_devices())
+       if (usb_find_devices() < 0) 
                return NULL;
        
        dev = find_opcd_device();
@@ -343,18 +398,19 @@ openpcd_open(void *data)
                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);
@@ -365,9 +421,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;
 }
@@ -378,18 +434,26 @@ 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,
+       .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,
@@ -401,6 +465,9 @@ struct rfid_reader rfid_reader_openpcd = {
        .iso14443b = {
                .init = &openpcd_14443b_init,
        },
+       .iso15693 = {
+               .init = &openpcd_15693_init,
+       },
        .mifare_classic = {
                .setkey = &openpcd_mifare_setkey,
                .auth = &openpcd_mifare_auth,