diff --git a/configure.ac b/configure.ac
index 3acf9b2..f650b56 100644
--- a/configure.ac
+++ b/configure.ac
@@ -138,6 +138,9 @@ CFLAGS="$CFLAGS -Wall -pedantic -Wextra"
 # Defines and C flags
 CFLAGS="$CFLAGS -std=c99"
 
+# Workarounds for libusb in c99
+CFLAGS="$CFLAGS -Du_int8_t=uint8_t -Du_int16_t=uint16_t"
+
 AC_CONFIG_FILES([
 		Doxyfile
 		Makefile
diff --git a/contrib/udev/42-pn53x.rules b/contrib/udev/42-pn53x.rules
index f679fcc..3118b4b 100644
--- a/contrib/udev/42-pn53x.rules
+++ b/contrib/udev/42-pn53x.rules
@@ -14,4 +14,8 @@ ATTRS{idVendor}=="04e6", ATTRS{idProduct}=="5591", MODE="0664", GROUP="plugdev"
 ATTRS{idVendor}=="1fd3", ATTRS{idProduct}=="0608", MODE="0664", GROUP="plugdev"
 ATTRS{idVendor}=="054c", ATTRS{idProduct}=="02e1", MODE="0664", GROUP="plugdev"
 
+# ACR122 / Touchatag
+ATTRS{idVendor}=="072f", ATTRS{idProduct}=="2200", MODE="0664", GROUP="plugdev"
+ATTRS{idVendor}=="072f", ATTRS{idProduct}=="90cc", MODE="0664", GROUP="plugdev"
+
 LABEL="pn53x_rules_end"
diff --git a/debian/control b/debian/control
index 32597f5..7130d67 100644
--- a/debian/control
+++ b/debian/control
@@ -2,7 +2,7 @@ Source: libnfc
 Section: libs
 Priority: extra
 Maintainer: Thomas Hood <jdthood@gmail.com>
-Build-Depends: debhelper (>= 7.0.50~), dh-autoreconf, libtool, pkg-config, libusb-dev, libpcsclite-dev
+Build-Depends: debhelper (>= 7.0.50~), dh-autoreconf, libtool, pkg-config, libusb-dev
 Standards-Version: 3.9.2
 Homepage: http://www.libnfc.org/
 Vcs-Svn: http://libnfc.googlecode.com/svn/trunk
@@ -11,7 +11,7 @@ Vcs-Browser: http://code.google.com/p/libnfc/source/browse/#svn/trunk
 Package: libnfc2
 Section: libs
 Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, libusb-0.1-4, libpcsclite1 (>= 1.5), libccid (>= 1.3.10), pcscd (>= 1.5)
+Depends: ${shlibs:Depends}, ${misc:Depends}, libusb-0.1-4
 Description: Near Field Communication (NFC) library
  libnfc is a Free Software library for Near Field Communication.
  Supported NFC hardware devices are, theorically, all hardware
@@ -20,7 +20,7 @@ Description: Near Field Communication (NFC) library
 Package: libnfc-dev
 Section: libdevel
 Architecture: any
-Depends: ${misc:Depends}, libnfc2 (= ${binary:Version}), libusb-dev, libpcsclite-dev
+Depends: ${misc:Depends}, libnfc2 (= ${binary:Version}), libusb-dev
 Description: Near Field Communication library (development files)
  libnfc is a free software library for near-field communication.
  It supports most hardware based on the NXP PN531, PN532 or PN533
diff --git a/debian/rules b/debian/rules
index c0f6d3d..04f4336 100755
--- a/debian/rules
+++ b/debian/rules
@@ -18,6 +18,8 @@ override_dh_installchangelogs:
 override_dh_auto_configure: 
 #	dh_auto_configure -- --enable-serial-autoprobe
 	dh_auto_configure -- --enable-debug --with-drivers=all --enable-serial-autoprobe
+#	dh_auto_configure -- --enable-debug --with-drivers=acr122_pcsc
+#	dh_auto_configure -- --enable-debug --with-drivers=pn532_uart,pn53x_usb --enable-serial-autoprobe
 
 %:
 	dh --with autoreconf $@
diff --git a/libnfc/drivers.h b/libnfc/drivers.h
index 694b160..e43c99f 100644
--- a/libnfc/drivers.h
+++ b/libnfc/drivers.h
@@ -28,9 +28,13 @@
 
 #  include <nfc/nfc-types.h>
 
-#  if defined (DRIVER_ACR122_ENABLED)
-#    include "drivers/acr122.h"
-#  endif /* DRIVER_ACR122_ENABLED */
+#  if defined (DRIVER_ACR122_PCSC_ENABLED)
+#    include "drivers/acr122_pcsc.h"
+#  endif /* DRIVER_ACR122_PCSC_ENABLED */
+
+#  if defined (DRIVER_ACR122_USB_ENABLED)
+#    include "drivers/acr122_usb.h"
+#  endif /* DRIVER_ACR122_USB_ENABLED */
 
 #  if defined (DRIVER_ACR122S_ENABLED)
 #    include "drivers/acr122s.h"
diff --git a/libnfc/drivers/Makefile.am b/libnfc/drivers/Makefile.am
index edfef5f..3ad71ec 100644
--- a/libnfc/drivers/Makefile.am
+++ b/libnfc/drivers/Makefile.am
@@ -1,15 +1,19 @@
 # set the include path found by configure
 INCLUDES= $(all_includes) $(LIBNFC_CFLAGS)
 
-noinst_HEADERS = acr122.h acr122s.h arygon.h pn532_uart.h pn53x_usb.h
+noinst_HEADERS = acr122_pcsc.h acr122_usb.h acr122s.h arygon.h pn532_uart.h pn53x_usb.h
 noinst_LTLIBRARIES = libnfcdrivers.la
 
 libnfcdrivers_la_SOURCES = 
 libnfcdrivers_la_CFLAGS = @DRIVERS_CFLAGS@ -I$(top_srcdir)/libnfc -I$(top_srcdir)/libnfc/buses
 libnfcdrivers_la_LIBADD = 
 
-if DRIVER_ACR122_ENABLED
-libnfcdrivers_la_SOURCES += acr122.c
+if DRIVER_ACR122_PCSC_ENABLED
+libnfcdrivers_la_SOURCES += acr122_pcsc.c
+endif
+
+if DRIVER_ACR122_USB_ENABLED
+libnfcdrivers_la_SOURCES += acr122_usb.c
 endif
 
 if DRIVER_ACR122S_ENABLED
diff --git a/libnfc/drivers/acr122.c b/libnfc/drivers/acr122_pcsc.c
similarity index 84%
rename from libnfc/drivers/acr122.c
rename to libnfc/drivers/acr122_pcsc.c
index e39b35c..4c89713 100644
--- a/libnfc/drivers/acr122.c
+++ b/libnfc/drivers/acr122_pcsc.c
@@ -2,6 +2,8 @@
  * Public platform independent Near Field Communication (NFC) library
  * 
  * Copyright (C) 2009, Roel Verdult
+ * Copyright (C) 2011, Romain Tartiere, Romuald Conty
+ * Copyright (C) 2012, Romuald Conty
  * 
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as published by the
@@ -18,8 +20,8 @@
  */
 
 /**
- * @file acr122.c
- * @brief Driver for ACR122 devices (e.g. Tikitag, Touchatag, ACS ACR122)
+ * @file acr122_pcsc.c
+ * @brief Driver for ACR122 devices (e.g. Tikitag, Touchatag, ACS ACR122) behind PC/SC
  */
 
 #ifdef HAVE_CONFIG_H
@@ -35,13 +37,13 @@
 #include <nfc/nfc.h>
 
 #include "chips/pn53x.h"
-#include "drivers/acr122.h"
+#include "drivers/acr122_pcsc.h"
 #include "nfc-internal.h"
 
 // Bus
 #include <winscard.h>
 
-#define ACR122_DRIVER_NAME "acr122"
+#define ACR122_PCSC_DRIVER_NAME "acr122"
 
 #if defined (_WIN32)
 #  define IOCTL_CCID_ESCAPE_SCARD_CTL_CODE SCARD_CTL_CODE(3500)
@@ -69,15 +71,15 @@
 
 #define FIRMWARE_TEXT "ACR122U" // Tested on: ACR122U101(ACS), ACR122U102(Tikitag), ACR122U203(ACS)
 
-#define ACR122_WRAP_LEN 5
-#define ACR122_COMMAND_LEN 266
-#define ACR122_RESPONSE_LEN 268
+#define ACR122_PCSC_WRAP_LEN 5
+#define ACR122_PCSC_COMMAND_LEN 266
+#define ACR122_PCSC_RESPONSE_LEN 268
 
 #define LOG_CATEGORY "libnfc.driver.acr122"
 
-const struct pn53x_io acr122_io;
+const struct pn53x_io acr122_pcsc_io;
 
-char   *acr122_firmware (nfc_device *pnd);
+char   *acr122_pcsc_firmware (nfc_device *pnd);
 
 const char *supported_devices[] = {
   "ACS ACR122",         // ACR122U & Touchatag, last version
@@ -87,20 +89,20 @@ const char *supported_devices[] = {
   NULL
 };
 
-struct acr122_data {
+struct acr122_pcsc_data {
   SCARDHANDLE hCard;
   SCARD_IO_REQUEST ioCard;
-  uint8_t  abtRx[ACR122_RESPONSE_LEN];
+  uint8_t  abtRx[ACR122_PCSC_RESPONSE_LEN];
   size_t  szRx;
 };
 
-#define DRIVER_DATA(pnd) ((struct acr122_data*)(pnd->driver_data))
+#define DRIVER_DATA(pnd) ((struct acr122_pcsc_data*)(pnd->driver_data))
 
 static SCARDCONTEXT _SCardContext;
 static int _iSCardContextRefCount = 0;
 
 SCARDCONTEXT *
-acr122_get_scardcontext (void)
+acr122_pcsc_get_scardcontext (void)
 {
   if (_iSCardContextRefCount == 0) {
     if (SCardEstablishContext (SCARD_SCOPE_USER, NULL, NULL, &_SCardContext) != SCARD_S_SUCCESS)
@@ -112,7 +114,7 @@ acr122_get_scardcontext (void)
 }
 
 void
-acr122_free_scardcontext (void)
+acr122_pcsc_free_scardcontext (void)
 {
   if (_iSCardContextRefCount) {
     _iSCardContextRefCount--;
@@ -134,7 +136,7 @@ acr122_free_scardcontext (void)
  * @return true if succeeded, false otherwise.
  */
 bool
-acr122_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszDeviceFound)
+acr122_pcsc_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszDeviceFound)
 {
   size_t  szPos = 0;
   char    acDeviceNames[256 + 64 * PCSC_MAX_DEVICES];
@@ -150,7 +152,7 @@ acr122_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszD
   *pszDeviceFound = 0;
 
   // Test if context succeeded
-  if (!(pscc = acr122_get_scardcontext ())) {
+  if (!(pscc = acr122_pcsc_get_scardcontext ())) {
     log_put (LOG_CATEGORY, NFC_PRIORITY_WARN, "%s", "PCSC context not found (make sure PCSC daemon is running).");
     return false;
   }
@@ -172,7 +174,7 @@ acr122_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszD
 
     if (bSupported) {
       // Supported ACR122 device found
-      snprintf (connstrings[*pszDeviceFound], sizeof(nfc_connstring), "%s:%s:%"PRIu32, ACR122_DRIVER_NAME, acDeviceNames + szPos, uiBusIndex);
+      snprintf (connstrings[*pszDeviceFound], sizeof(nfc_connstring), "%s:%s:%"PRIu32, ACR122_PCSC_DRIVER_NAME, acDeviceNames + szPos, uiBusIndex);
       (*pszDeviceFound)++;
     } else {
       log_put (LOG_CATEGORY, NFC_PRIORITY_TRACE, "PCSC device [%s] is not NFC capable or not supported by libnfc.", acDeviceNames + szPos);
@@ -181,18 +183,18 @@ acr122_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszD
     // Find next device name position
     while (acDeviceNames[szPos++] != '\0');
   }
-  acr122_free_scardcontext ();
+  acr122_pcsc_free_scardcontext ();
 
   return true;
 }
 
-struct acr122_descriptor {
+struct acr122_pcsc_descriptor {
   char pcsc_device_name[512];
   int bus_index;
 };
 
 int
-acr122_connstring_decode (const nfc_connstring connstring, struct acr122_descriptor *desc)
+acr122_pcsc_connstring_decode (const nfc_connstring connstring, struct acr122_pcsc_descriptor *desc)
 {
   char *cs = malloc (strlen (connstring) + 1);
   if (!cs) {
@@ -207,7 +209,7 @@ acr122_connstring_decode (const nfc_connstring connstring, struct acr122_descrip
     return -1;
   }
 
-  if (0 != strcmp (driver_name, ACR122_DRIVER_NAME)) {
+  if (0 != strcmp (driver_name, ACR122_PCSC_DRIVER_NAME)) {
     // Driver name does not match.
     free (cs);
     return 0;
@@ -241,28 +243,28 @@ acr122_connstring_decode (const nfc_connstring connstring, struct acr122_descrip
 }
 
 nfc_device *
-acr122_open (const nfc_connstring connstring)
+acr122_pcsc_open (const nfc_connstring connstring)
 {
-  struct acr122_descriptor ndd;
-  int connstring_decode_level = acr122_connstring_decode (connstring, &ndd);
+  struct acr122_pcsc_descriptor ndd;
+  int connstring_decode_level = acr122_pcsc_connstring_decode (connstring, &ndd);
 
   if (connstring_decode_level < 2) {
     return NULL;
   }
-  // FIXME: acr122_open() does not take care about bus index
+  // FIXME: acr122_pcsc_open() does not take care about bus index
 
   char   *pcFirmware;
   nfc_device *pnd = nfc_device_new (connstring);
-  pnd->driver_data = malloc (sizeof (struct acr122_data));
+  pnd->driver_data = malloc (sizeof (struct acr122_pcsc_data));
 
   // Alloc and init chip's data
-  pn53x_data_new (pnd, &acr122_io);
+  pn53x_data_new (pnd, &acr122_pcsc_io);
 
   SCARDCONTEXT *pscc;
   
   log_put (LOG_CATEGORY, NFC_PRIORITY_TRACE, "Attempt to open %s", ndd.pcsc_device_name);
   // Test if context succeeded
-  if (!(pscc = acr122_get_scardcontext ()))
+  if (!(pscc = acr122_pcsc_get_scardcontext ()))
     goto error;
   // Test if we were able to connect to the "emulator" card
   if (SCardConnect (*pscc, ndd.pcsc_device_name, SCARD_SHARE_EXCLUSIVE, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &(DRIVER_DATA (pnd)->hCard), (void *) &(DRIVER_DATA (pnd)->ioCard.dwProtocol)) != SCARD_S_SUCCESS) {
@@ -277,7 +279,7 @@ acr122_open (const nfc_connstring connstring)
   DRIVER_DATA (pnd)->ioCard.cbPciLength = sizeof (SCARD_IO_REQUEST);
 
   // Retrieve the current firmware version
-  pcFirmware = acr122_firmware (pnd);
+  pcFirmware = acr122_pcsc_firmware (pnd);
   if (strstr (pcFirmware, FIRMWARE_TEXT) != NULL) {
 
     // Done, we found the reader we are looking for
@@ -287,7 +289,7 @@ acr122_open (const nfc_connstring connstring)
     // 46: empirical tuning on ACR122U
     CHIP_DATA (pnd)->timer_correction = 50;
 
-    pnd->driver = &acr122_driver;
+    pnd->driver = &acr122_pcsc_driver;
 
     pn53x_init (pnd);
 
@@ -301,30 +303,30 @@ error:
 }
 
 void
-acr122_close (nfc_device *pnd)
+acr122_pcsc_close (nfc_device *pnd)
 {
   SCardDisconnect (DRIVER_DATA (pnd)->hCard, SCARD_LEAVE_CARD);
-  acr122_free_scardcontext ();
+  acr122_pcsc_free_scardcontext ();
 
   pn53x_data_free (pnd);
   nfc_device_free (pnd);
 }
 
 int
-acr122_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int timeout)
+acr122_pcsc_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int timeout)
 {
   // FIXME: timeout is not handled
   (void) timeout;
 
   // Make sure the command does not overflow the send buffer
-  if (szData > ACR122_COMMAND_LEN) {
+  if (szData > ACR122_PCSC_COMMAND_LEN) {
     pnd->last_error = NFC_EINVARG;
     return pnd->last_error;
   }
 
   // Prepare and transmit the send buffer
   const size_t szTxBuf = szData + 6;
-  uint8_t  abtTxBuf[ACR122_WRAP_LEN + ACR122_COMMAND_LEN] = { 0xFF, 0x00, 0x00, 0x00, szData + 1, 0xD4 };
+  uint8_t  abtTxBuf[ACR122_PCSC_WRAP_LEN + ACR122_PCSC_COMMAND_LEN] = { 0xFF, 0x00, 0x00, 0x00, szData + 1, 0xD4 };
   memcpy (abtTxBuf + 6, pbtData, szData);
   LOG_HEX ("TX", abtTxBuf, szTxBuf);
 
@@ -344,7 +346,7 @@ acr122_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int t
      * This state is generaly reached when the ACR122 has no target in it's
      * field.
      */
-    if (SCardControl (DRIVER_DATA (pnd)->hCard, IOCTL_CCID_ESCAPE_SCARD_CTL_CODE, abtTxBuf, szTxBuf, DRIVER_DATA (pnd)->abtRx, ACR122_RESPONSE_LEN, &dwRxLen) != SCARD_S_SUCCESS) {
+    if (SCardControl (DRIVER_DATA (pnd)->hCard, IOCTL_CCID_ESCAPE_SCARD_CTL_CODE, abtTxBuf, szTxBuf, DRIVER_DATA (pnd)->abtRx, ACR122_PCSC_RESPONSE_LEN, &dwRxLen) != SCARD_S_SUCCESS) {
       pnd->last_error = NFC_EIO;
       return pnd->last_error;
     }
@@ -382,7 +384,7 @@ acr122_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int t
 }
 
 int
-acr122_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int timeout)
+acr122_pcsc_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int timeout)
 {
   // FIXME: timeout is not handled
   (void) timeout;
@@ -403,7 +405,7 @@ acr122_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int time
     DRIVER_DATA (pnd)->szRx = dwRxLen;
   } else {
     /*
-     * We already have the PN532 answer, it was saved by acr122_send().
+     * We already have the PN532 answer, it was saved by acr122_pcsc_send().
      */
   }
   LOG_HEX ("RX", DRIVER_DATA (pnd)->abtRx, DRIVER_DATA (pnd)->szRx);
@@ -421,7 +423,7 @@ acr122_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int time
 }
 
 char   *
-acr122_firmware (nfc_device *pnd)
+acr122_pcsc_firmware (nfc_device *pnd)
 {
   uint8_t  abtGetFw[5] = { 0xFF, 0x00, 0x48, 0x00, 0x00 };
   uint32_t uiResult;
@@ -444,7 +446,7 @@ acr122_firmware (nfc_device *pnd)
 
 #if 0
 bool
-acr122_led_red (nfc_device *pnd, bool bOn)
+acr122_pcsc_led_red (nfc_device *pnd, bool bOn)
 {
   uint8_t  abtLed[9] = { 0xFF, 0x00, 0x40, 0x05, 0x04, 0x00, 0x00, 0x00, 0x00 };
   uint8_t  abtBuf[2];
@@ -458,16 +460,16 @@ acr122_led_red (nfc_device *pnd, bool bOn)
 }
 #endif
 
-const struct pn53x_io acr122_io = {
-  .send    = acr122_send,
-  .receive = acr122_receive,
+const struct pn53x_io acr122_pcsc_io = {
+  .send    = acr122_pcsc_send,
+  .receive = acr122_pcsc_receive,
 };
 
-const struct nfc_driver acr122_driver = {
-  .name                             = ACR122_DRIVER_NAME,
-  .probe                            = acr122_probe,
-  .open                             = acr122_open,
-  .close                            = acr122_close,
+const struct nfc_driver acr122_pcsc_driver = {
+  .name                             = ACR122_PCSC_DRIVER_NAME,
+  .probe                            = acr122_pcsc_probe,
+  .open                             = acr122_pcsc_open,
+  .close                            = acr122_pcsc_close,
   .strerror                         = pn53x_strerror,
 
   .initiator_init                   = pn53x_initiator_init,
diff --git a/libnfc/drivers/acr122.h b/libnfc/drivers/acr122_pcsc.h
similarity index 54%
rename from libnfc/drivers/acr122.h
rename to libnfc/drivers/acr122_pcsc.h
index 5c2ba98..3caf3a0 100644
--- a/libnfc/drivers/acr122.h
+++ b/libnfc/drivers/acr122_pcsc.h
@@ -2,6 +2,8 @@
  * Public platform independent Near Field Communication (NFC) library
  * 
  * Copyright (C) 2009, Roel Verdult
+ * Copyright (C) 2011, Romain Tartiere, Romuald Conty
+ * Copyright (C) 2012, Romuald Conty
  * 
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as published by the
@@ -17,23 +19,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  * 
  * 
- * @file acr122.h
- * @brief Driver for ACR122 devices
+ * @file acr122_pcsc.h
+ * @brief Driver for ACR122 devices (behind PC/SC daemon)
  */
 
-#ifndef __NFC_DRIVER_ACR122_H__
-#  define __NFC_DRIVER_ACR122_H__
+#ifndef __NFC_DRIVER_ACR122_PCSC_H__
+#  define __NFC_DRIVER_ACR122_PCSC_H__
 
 #  include <nfc/nfc-types.h>
 
-bool    acr122_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszDeviceFound);
+bool    acr122_pcsc_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszDeviceFound);
 
 // Functions used by developer to handle connection to this device
-nfc_device *acr122_open (const nfc_connstring connstring);
-int    acr122_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int timeout);
-int     acr122_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int timeout);
-void    acr122_close (nfc_device *pnd);
+nfc_device *acr122_pcsc_open (const nfc_connstring connstring);
+int    acr122_pcsc_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int timeout);
+int     acr122_pcsc_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int timeout);
+void    acr122_pcsc_close (nfc_device *pnd);
 
-extern const struct nfc_driver acr122_driver;
+extern const struct nfc_driver acr122_pcsc_driver;
 
-#endif // ! __NFC_DRIVER_ACR122_H__
+#endif // ! __NFC_DRIVER_ACR122_PCSC_H__
diff --git a/libnfc/drivers/acr122_usb.c b/libnfc/drivers/acr122_usb.c
new file mode 100644
index 0000000..b52177d
--- /dev/null
+++ b/libnfc/drivers/acr122_usb.c
@@ -0,0 +1,649 @@
+/*-
+ * Public platform independent Near Field Communication (NFC) library
+ * 
+ * Copyright (C) 2009, Roel Verdult
+ * Copyright (C) 2010, Romain Tartière, Romuald Conty
+ * Copyright (C) 2011, Romain Tartière, Romuald Conty
+ * 
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+/**
+ * @file acr122_usb.c
+ * @brief Driver for ACR122 using direct USB (without PCSC)
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif // HAVE_CONFIG_H
+
+/*
+Thanks to d18c7db and Okko for example code
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <sys/select.h>
+#include <errno.h>
+
+#ifndef _WIN32
+  // Under POSIX system, we use libusb (>= 0.1.12)
+  #include <usb.h>
+  #define USB_TIMEDOUT ETIMEDOUT
+  #define _usb_strerror( X ) strerror(-X)
+#else
+  // Under Windows we use libusb-win32 (>= 1.2.5)
+  #include <lusb0_usb.h>
+  #define USB_TIMEDOUT 116
+  #define _usb_strerror( X ) usb_strerror()
+#endif
+
+#include <string.h>
+
+#include <nfc/nfc.h>
+
+#include "nfc-internal.h"
+#include "chips/pn53x.h"
+#include "chips/pn53x-internal.h"
+#include "drivers/acr122_usb.h"
+
+#define ACR122_USB_DRIVER_NAME "acr122_usb"
+#define LOG_CATEGORY "libnfc.driver.acr122_usb"
+
+#define USB_INFINITE_TIMEOUT   0
+
+#define DRIVER_DATA(pnd) ((struct acr122_usb_data*)(pnd->driver_data))
+
+typedef enum {
+  UNKNOWN,
+  ACR122,
+  TOUCHATAG,
+} acr122_usb_model;
+
+struct acr122_usb_data {
+  usb_dev_handle *pudh;
+  acr122_usb_model model;
+  uint32_t uiEndPointIn;
+  uint32_t uiEndPointOut;
+  uint32_t uiMaxPacketSize;
+  volatile bool abort_flag;
+};
+
+const struct pn53x_io acr122_usb_io;
+bool acr122_usb_get_usb_device_name (struct usb_device *dev, usb_dev_handle *udev, char *buffer, size_t len);
+int acr122_usb_init (nfc_device *pnd);
+
+int
+acr122_usb_bulk_read (struct acr122_usb_data *data, uint8_t abtRx[], const size_t szRx, const int timeout)
+{
+  int res = usb_bulk_read (data->pudh, data->uiEndPointIn, (char *) abtRx, szRx, timeout);
+  if (res > 0) {
+    LOG_HEX ("RX", abtRx, res);
+  } else if (res < 0) {
+    if (res != -USB_TIMEDOUT) {
+      res = NFC_EIO;
+      log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to read from USB (%s)", _usb_strerror (res));
+    } else {
+      res = NFC_ETIMEOUT;
+    }
+  }
+  return res;
+}
+
+int
+acr122_usb_bulk_write (struct acr122_usb_data *data, uint8_t abtTx[], const size_t szTx, const int timeout)
+{
+  LOG_HEX ("TX", abtTx, szTx);
+  int res = usb_bulk_write (data->pudh, data->uiEndPointOut, (char *) abtTx, szTx, timeout);
+  if (res > 0) {
+    // HACK This little hack is a well know problem of USB, see http://www.libusb.org/ticket/6 for more details
+    if ((res % data->uiMaxPacketSize) == 0) {
+      usb_bulk_write (data->pudh, data->uiEndPointOut, "\0", 0, timeout);
+    }
+  } else if (res < 0) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to write to USB (%s)", _usb_strerror (res));
+    if (res == -USB_TIMEDOUT) {
+      res = NFC_ETIMEOUT;
+    } else {
+      res = NFC_EIO;
+    }
+  }
+  return res;
+}
+
+struct acr122_usb_supported_device {
+  uint16_t vendor_id;
+  uint16_t product_id;
+  acr122_usb_model model;
+  const char *name;
+};
+
+const struct acr122_usb_supported_device acr122_usb_supported_devices[] = {
+  { 0x072F, 0x2200, ACR122,   "ACS ACR122" },
+  { 0x072F, 0x90CC, TOUCHATAG,   "Touchatag" },
+};
+
+acr122_usb_model
+acr122_usb_get_device_model (uint16_t vendor_id, uint16_t product_id)
+{
+  for (size_t n = 0; n < sizeof (acr122_usb_supported_devices) / sizeof (struct acr122_usb_supported_device); n++) {
+    if ((vendor_id == acr122_usb_supported_devices[n].vendor_id) &&
+       (product_id == acr122_usb_supported_devices[n].product_id))
+      return acr122_usb_supported_devices[n].model;
+  }
+
+  return UNKNOWN;
+}
+
+int  acr122_usb_ack (nfc_device *pnd);
+
+// Find transfer endpoints for bulk transfers
+void
+acr122_usb_get_end_points (struct usb_device *dev, struct acr122_usb_data *data)
+{
+  uint32_t uiIndex;
+  uint32_t uiEndPoint;
+  struct usb_interface_descriptor *puid = dev->config->interface->altsetting;
+
+  // 3 Endpoints maximum: Interrupt In, Bulk In, Bulk Out
+  for (uiIndex = 0; uiIndex < puid->bNumEndpoints; uiIndex++) {
+    // Only accept bulk transfer endpoints (ignore interrupt endpoints)
+    if (puid->endpoint[uiIndex].bmAttributes != USB_ENDPOINT_TYPE_BULK)
+      continue;
+
+    // Copy the endpoint to a local var, makes it more readable code
+    uiEndPoint = puid->endpoint[uiIndex].bEndpointAddress;
+
+    // Test if we dealing with a bulk IN endpoint
+    if ((uiEndPoint & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_IN) {
+      data->uiEndPointIn = uiEndPoint;
+      data->uiMaxPacketSize = puid->endpoint[uiIndex].wMaxPacketSize;
+    }
+    // Test if we dealing with a bulk OUT endpoint
+    if ((uiEndPoint & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_OUT) {
+      data->uiEndPointOut = uiEndPoint;
+      data->uiMaxPacketSize = puid->endpoint[uiIndex].wMaxPacketSize;
+    }
+  }
+}
+
+bool
+acr122_usb_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszDeviceFound)
+{
+  usb_init ();
+
+  int res;
+  // usb_find_busses will find all of the busses on the system. Returns the
+  // number of changes since previous call to this function (total of new
+  // busses and busses removed).
+  if ((res = usb_find_busses () < 0)) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to find USB busses (%s)", _usb_strerror (res));
+    return false;
+  }
+  // usb_find_devices will find all of the devices on each bus. This should be
+  // called after usb_find_busses. Returns the number of changes since the
+  // previous call to this function (total of new device and devices removed).
+  if ((res = usb_find_devices () < 0)) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to find USB devices (%s)", _usb_strerror (res));
+    return false;
+  }
+
+  *pszDeviceFound = 0;
+
+  uint32_t uiBusIndex = 0;
+  struct usb_bus *bus;
+  for (bus = usb_get_busses (); bus; bus = bus->next) {
+    struct usb_device *dev;
+
+    for (dev = bus->devices; dev; dev = dev->next, uiBusIndex++) {
+      for (size_t n = 0; n < sizeof (acr122_usb_supported_devices) / sizeof (struct acr122_usb_supported_device); n++) {
+        if ((acr122_usb_supported_devices[n].vendor_id == dev->descriptor.idVendor) &&
+            (acr122_usb_supported_devices[n].product_id == dev->descriptor.idProduct)) {
+          // Make sure there are 2 endpoints available
+          // with libusb-win32 we got some null pointers so be robust before looking at endpoints:
+          if (dev->config == NULL || dev->config->interface == NULL || dev->config->interface->altsetting == NULL) {
+            // Nope, we maybe want the next one, let's try to find another
+            continue;
+          }
+          if (dev->config->interface->altsetting->bNumEndpoints < 2) {
+            // Nope, we maybe want the next one, let's try to find another
+            continue;
+          }
+
+          usb_dev_handle *udev = usb_open (dev);
+
+          // Set configuration
+          // acr122_usb_get_usb_device_name (dev, udev, pnddDevices[*pszDeviceFound].acDevice, sizeof (pnddDevices[*pszDeviceFound].acDevice));
+          log_put (LOG_CATEGORY, NFC_PRIORITY_TRACE, "device found: Bus %s Device %s", bus->dirname, dev->filename);
+          usb_close (udev);
+          snprintf (connstrings[*pszDeviceFound], sizeof(nfc_connstring), "%s:%s:%s", ACR122_USB_DRIVER_NAME, bus->dirname, dev->filename);
+          (*pszDeviceFound)++;
+          // Test if we reach the maximum "wanted" devices
+          if ((*pszDeviceFound) == connstrings_len) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+struct acr122_usb_descriptor {
+  char *dirname;
+  char *filename;
+};
+
+int
+acr122_usb_connstring_decode (const nfc_connstring connstring, struct acr122_usb_descriptor *desc)
+{
+  int n = strlen (connstring) + 1;
+  char *driver_name = malloc (n);
+  char *dirname     = malloc (n);
+  char *filename    = malloc (n);
+
+  driver_name[0] = '\0';
+
+  int res = sscanf (connstring, "%[^:]:%[^:]:%[^:]", driver_name, dirname, filename);
+
+  if (!res || (0 != strcmp (driver_name, ACR122_USB_DRIVER_NAME))) {
+    // Driver name does not match.
+    res = 0;
+  } else {
+    desc->dirname  = strdup (dirname);
+    desc->filename = strdup (filename);
+  }
+
+  free (driver_name);
+  free (dirname);
+  free (filename);
+
+  return res;
+}
+
+bool
+acr122_usb_get_usb_device_name (struct usb_device *dev, usb_dev_handle *udev, char *buffer, size_t len)
+{
+  *buffer = '\0';
+
+  if (dev->descriptor.iManufacturer || dev->descriptor.iProduct) {
+    if (udev) {
+      usb_get_string_simple (udev, dev->descriptor.iManufacturer, buffer, len);
+      if (strlen (buffer) > 0)
+        strcpy (buffer + strlen (buffer), " / ");
+      usb_get_string_simple (udev, dev->descriptor.iProduct, buffer + strlen (buffer), len - strlen (buffer));
+    }
+  }
+
+  if (!*buffer) {
+    for (size_t n = 0; n < sizeof (acr122_usb_supported_devices) / sizeof (struct acr122_usb_supported_device); n++) {
+      if ((acr122_usb_supported_devices[n].vendor_id == dev->descriptor.idVendor) &&
+          (acr122_usb_supported_devices[n].product_id == dev->descriptor.idProduct)) {
+        strncpy (buffer, acr122_usb_supported_devices[n].name, len);
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+nfc_device *
+acr122_usb_open (const nfc_connstring connstring)
+{
+  nfc_device *pnd = NULL;
+  struct acr122_usb_descriptor desc = { NULL, NULL };
+  int connstring_decode_level = acr122_usb_connstring_decode (connstring, &desc);
+  log_put (LOG_CATEGORY, NFC_PRIORITY_TRACE, "%d element(s) have been decoded from \"%s\"", connstring_decode_level, connstring);
+  if (connstring_decode_level < 1) {
+    goto free_mem;
+  }
+
+  struct acr122_usb_data data = {
+    .pudh = NULL,
+    .uiEndPointIn = 0,
+    .uiEndPointOut = 0,
+  };
+  struct usb_bus *bus;
+  struct usb_device *dev;
+
+  usb_init ();
+
+  int res;
+  // usb_find_busses will find all of the busses on the system. Returns the
+  // number of changes since previous call to this function (total of new
+  // busses and busses removed).
+  if ((res = usb_find_busses () < 0)) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to find USB busses (%s)", _usb_strerror (res));
+    goto free_mem;
+  }
+  // usb_find_devices will find all of the devices on each bus. This should be
+  // called after usb_find_busses. Returns the number of changes since the
+  // previous call to this function (total of new device and devices removed).
+  if ((res = usb_find_devices () < 0)) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to find USB devices (%s)", _usb_strerror (res));
+    goto free_mem;
+  }
+
+  for (bus = usb_get_busses (); bus; bus = bus->next) {
+    if (connstring_decode_level > 1)  {
+      // A specific bus have been specified
+      if (0 != strcmp (bus->dirname, desc.dirname))
+        continue;
+    }
+    for (dev = bus->devices; dev; dev = dev->next) {
+      if (connstring_decode_level > 2)  {
+        // A specific dev have been specified
+      if (0 != strcmp (dev->filename, desc.filename))
+          continue;
+      }
+      // Open the USB device
+      data.pudh = usb_open (dev);
+      // Reset device
+      usb_reset (data.pudh);
+      // Retrieve end points
+      acr122_usb_get_end_points (dev, &data);
+      // Claim interface
+      res = usb_claim_interface (data.pudh, 0);
+      if (res < 0) {
+        log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to claim USB interface (%s)", _usb_strerror (res));
+        usb_close (data.pudh);
+        // we failed to use the specified device
+        goto free_mem;
+      }
+
+      res = usb_set_altinterface (data.pudh, 0);
+      if (res < 0) {
+        log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to set alternate setting on USB interface (%s)", _usb_strerror (res));
+        usb_close (data.pudh);
+        // we failed to use the specified device
+        goto free_mem;
+      }
+
+      data.model = acr122_usb_get_device_model (dev->descriptor.idVendor, dev->descriptor.idProduct);
+      // Allocate memory for the device info and specification, fill it and return the info
+      pnd = nfc_device_new (connstring);
+      acr122_usb_get_usb_device_name (dev, data.pudh, pnd->name, sizeof (pnd->name));
+
+      pnd->driver_data = malloc(sizeof(struct acr122_usb_data));
+      *DRIVER_DATA (pnd) = data;
+
+      // Alloc and init chip's data
+      pn53x_data_new (pnd, &acr122_usb_io);
+
+      switch (DRIVER_DATA (pnd)->model) {
+        // empirical tuning
+        case ACR122:
+          CHIP_DATA (pnd)->timer_correction = 46;
+          break;
+        case TOUCHATAG:
+          CHIP_DATA (pnd)->timer_correction = 50;
+          break;
+        default:
+          break;
+      }
+      pnd->driver = &acr122_usb_driver;
+
+      // HACK1: Send first an ACK as Abort command, to reset chip before talking to it:
+      acr122_usb_ack (pnd);
+
+      // HACK2: Then send a GetFirmware command to resync USB toggle bit between host & device
+      // in case host used set_configuration and expects the device to have reset its toggle bit, which PN53x doesn't do
+      if (acr122_usb_init (pnd) < 0) {
+        usb_close (data.pudh);
+        goto error;
+      }
+      DRIVER_DATA (pnd)->abort_flag = false;
+      goto free_mem;
+    }
+  }
+  // We ran out of devices before the index required
+  goto free_mem;
+
+error:
+  // Free allocated structure on error.
+  nfc_device_free (pnd);
+  pnd = NULL;
+free_mem:
+  free (desc.dirname);
+  free (desc.filename);
+  return pnd;
+}
+
+void
+acr122_usb_close (nfc_device *pnd)
+{
+  acr122_usb_ack (pnd);
+
+  pn53x_idle (pnd);
+
+  int res;
+  if ((res = usb_release_interface (DRIVER_DATA (pnd)->pudh, 0)) < 0) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to release USB interface (%s)", _usb_strerror (res));
+  }
+
+  if ((res = usb_close (DRIVER_DATA (pnd)->pudh)) < 0) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to close USB connection (%s)", _usb_strerror (res));
+  }
+  pn53x_data_free (pnd);
+  nfc_device_free (pnd);
+}
+
+#define ACR122_USB_BUFFER_LEN (PN53x_EXTENDED_FRAME__DATA_MAX_LEN + PN53x_EXTENDED_FRAME__OVERHEAD)
+size_t
+acr122_build_frame (uint8_t *frame, const size_t frame_len, const uint8_t *data, const size_t data_len)
+{
+  frame[1] = data_len + 6;
+  frame[14] = data_len + 1;
+  memcpy (frame + 16, data, data_len);
+  return data_len + 16;
+}
+
+int
+acr122_usb_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, const int timeout)
+{
+  uint8_t  abtFrame[ACR122_USB_BUFFER_LEN] = { 0x6b, 
+                                               0x00, // len
+                                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // padding
+                                               0xff, 0x00, 0x00, 0x00,
+                                               0x00, // pn532 command lenght
+                                               0xd4, // direction
+  };
+  size_t szFrame = acr122_build_frame (abtFrame, sizeof(abtFrame), pbtData, szData);
+
+  int res;
+  if ((res = acr122_usb_bulk_write (DRIVER_DATA (pnd), abtFrame, szFrame, timeout)) < 0) {
+    pnd->last_error = res;
+    return pnd->last_error;
+  }
+  return NFC_SUCCESS;
+}
+
+#define USB_TIMEOUT_PER_PASS 200
+int
+acr122_usb_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szDataLen, const int timeout)
+{
+  off_t offset = 0;
+
+  uint8_t  abtRxBuf[ACR122_USB_BUFFER_LEN];
+  int res;
+
+  /*
+   * If no timeout is specified but the command is blocking, force a 200ms (USB_TIMEOUT_PER_PASS)
+   * timeout to allow breaking the loop if the user wants to stop it.
+   */
+  int usb_timeout;
+  int remaining_time = timeout;
+read:
+  if (timeout == USB_INFINITE_TIMEOUT) {
+    usb_timeout = USB_TIMEOUT_PER_PASS;
+  } else {
+    // A user-provided timeout is set, we have to cut it in multiple chunk to be able to keep an nfc_abort_command() mecanism
+    remaining_time -= USB_TIMEOUT_PER_PASS;
+    if (remaining_time <= 0) {
+      pnd->last_error = NFC_ETIMEOUT;
+      return pnd->last_error;
+    } else {
+      usb_timeout = MIN(remaining_time, USB_TIMEOUT_PER_PASS);
+    }
+  }
+
+  res = acr122_usb_bulk_read (DRIVER_DATA (pnd), abtRxBuf, sizeof (abtRxBuf), usb_timeout);
+
+  if (res == NFC_ETIMEOUT) {
+    if (DRIVER_DATA (pnd)->abort_flag) {
+      DRIVER_DATA (pnd)->abort_flag = false;
+      acr122_usb_ack (pnd);
+      pnd->last_error = NFC_EOPABORTED;
+      return pnd->last_error;
+    } else {
+      goto read;
+    }
+  }
+
+  if (res < 0) {
+    // try to interrupt current device state
+    acr122_usb_ack(pnd);
+    pnd->last_error = res;
+    return pnd->last_error;
+  }
+
+  if (abtRxBuf[offset] != 0x83) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "%s", "Frame header mismatch");
+    pnd->last_error = NFC_EIO;
+    return pnd->last_error;
+  }
+  offset++;
+
+  size_t len = abtRxBuf[offset++];
+  if (len < 4) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Too small reply");
+    pnd->last_error = NFC_EIO;
+    return pnd->last_error;
+  }
+  len -= 4;
+
+  if (len > szDataLen) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to receive data: buffer too small. (szDataLen: %zu, len: %zu)", szDataLen, len);
+    pnd->last_error = NFC_EIO;
+    return pnd->last_error;
+  }
+
+  const uint8_t acr122_preamble[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x81, 0x00 };
+  if (0 != (memcmp (abtRxBuf + offset, acr122_preamble, sizeof(acr122_preamble)))) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "%s", "Frame preamble mismatch");
+    pnd->last_error = NFC_EIO;
+    return pnd->last_error;
+  }
+  offset += sizeof(acr122_preamble);
+
+  // TFI + PD0 (CC+1)
+  if (abtRxBuf[offset] != 0xD5) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "%s", "TFI Mismatch");
+    pnd->last_error = NFC_EIO;
+    return pnd->last_error;
+  }
+  offset += 1;
+
+  if (abtRxBuf[offset] != CHIP_DATA (pnd)->last_command + 1) {
+    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "%s", "Command Code verification failed");
+    pnd->last_error = NFC_EIO;
+    return pnd->last_error;
+  }
+  offset += 1;
+
+  memcpy (pbtData, abtRxBuf + offset, len);
+  offset += len;
+
+  return len;
+}
+
+int
+acr122_usb_ack (nfc_device *pnd)
+{
+  return 0;
+  //return acr122_usb_bulk_write (DRIVER_DATA (pnd), (uint8_t *) pn53x_ack_frame, sizeof (pn53x_ack_frame), 1000);
+}
+
+int
+acr122_usb_init (nfc_device *pnd)
+{
+  int res = 0;
+/*
+  uint8_t frame[] = { 0x6B,
+			0x07,
+			0, 0, 0, 0, 0, 0, 0, 0, // padding
+			0xFF, 0x00, 0x00, 0x00, 0x02, 0xD4, 0x02 // frame
+                    };
+  acr122_usb_bulk_write (DRIVER_DATA (pnd), frame, sizeof(frame), 300);
+  acr122_usb_bulk_read (DRIVER_DATA (pnd), frame, sizeof(frame), 0);
+*/
+
+/*
+  uint8_t frame[] = { 0x6B,
+			5, // len
+			0, 0, 0, 0, 0, 0, 0, 0, // padding
+			0xFF, 0x00, 0x48, 0x00, 0x00 // frame
+                    };
+  acr122_usb_bulk_write (DRIVER_DATA (pnd), frame, sizeof(frame), 0);
+*/
+  if ((res = pn53x_init (pnd)) < 0)
+    return res;
+
+  return NFC_SUCCESS;
+}
+
+int
+acr122_usb_abort_command (nfc_device *pnd)
+{
+  DRIVER_DATA (pnd)->abort_flag = true;
+  return NFC_SUCCESS;
+}
+
+const struct pn53x_io acr122_usb_io = {
+  .send       = acr122_usb_send,
+  .receive    = acr122_usb_receive,
+};
+
+const struct nfc_driver acr122_usb_driver = {
+  .name                             = ACR122_USB_DRIVER_NAME,
+  .probe                            = acr122_usb_probe,
+  .open                             = acr122_usb_open,
+  .close                            = acr122_usb_close,
+  .strerror                         = pn53x_strerror,
+
+  .initiator_init                   = pn53x_initiator_init,
+  .initiator_select_passive_target  = pn53x_initiator_select_passive_target,
+  .initiator_poll_target            = pn53x_initiator_poll_target,
+  .initiator_select_dep_target      = pn53x_initiator_select_dep_target,
+  .initiator_deselect_target        = pn53x_initiator_deselect_target,
+  .initiator_transceive_bytes       = pn53x_initiator_transceive_bytes,
+  .initiator_transceive_bits        = pn53x_initiator_transceive_bits,
+  .initiator_transceive_bytes_timed = pn53x_initiator_transceive_bytes_timed,
+  .initiator_transceive_bits_timed  = pn53x_initiator_transceive_bits_timed,
+
+  .target_init           = pn53x_target_init,
+  .target_send_bytes     = pn53x_target_send_bytes,
+  .target_receive_bytes  = pn53x_target_receive_bytes,
+  .target_send_bits      = pn53x_target_send_bits,
+  .target_receive_bits   = pn53x_target_receive_bits,
+
+  .device_set_property_bool  = pn53x_set_property_bool,
+  .device_set_property_int = pn53x_set_property_int,
+
+  .abort_command  = acr122_usb_abort_command,
+  .idle  = pn53x_idle,
+};
diff --git a/libnfc/drivers/acr122_usb.h b/libnfc/drivers/acr122_usb.h
new file mode 100644
index 0000000..76ca4d9
--- /dev/null
+++ b/libnfc/drivers/acr122_usb.h
@@ -0,0 +1,40 @@
+/**
+ * Public platform independent Near Field Communication (NFC) library
+ * 
+ * Copyright (C) 2009, Roel Verdult
+ * Copyright (C) 2011, Romain Tartière
+ * 
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * 
+ * 
+ * @file acr122_usb.h
+ * @brief Driver for ACR122 devices using direct USB connection (without PCSC)
+ */
+
+#ifndef __NFC_DRIVER_ACR122_USB_H__
+#  define __NFC_DRIVER_ACR122_USB_H__
+
+#  include <sys/time.h>
+
+#  include <nfc/nfc-types.h>
+
+bool    acr122_usb_probe (nfc_connstring connstrings[], size_t connstrings_len, size_t *pszDeviceFound);
+nfc_device *acr122_usb_connect (const nfc_connstring connstring);
+int    acr122_usb_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int timeout);
+int    acr122_usb_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int timeout);
+void    acr122_usb_disconnect (nfc_device *pnd);
+
+extern const struct nfc_driver acr122_usb_driver;
+
+#endif // ! __NFC_DRIVER_ACR122_USB_H__
diff --git a/libnfc/drivers/pn53x_usb.c b/libnfc/drivers/pn53x_usb.c
index ca871a6..24308b9 100644
--- a/libnfc/drivers/pn53x_usb.c
+++ b/libnfc/drivers/pn53x_usb.c
@@ -312,7 +312,7 @@ nfc_device *
 pn53x_usb_open (const nfc_connstring connstring)
 {
   nfc_device *pnd = NULL;
-  struct pn53x_usb_descriptor desc = { NULL, NULL } ;
+  struct pn53x_usb_descriptor desc = { NULL, NULL };
   int connstring_decode_level = pn53x_usb_connstring_decode (connstring, &desc);
   log_put (LOG_CATEGORY, NFC_PRIORITY_TRACE, "%d element(s) have been decoded from \"%s\"", connstring_decode_level, connstring);
   if (connstring_decode_level < 1) {
@@ -480,9 +480,9 @@ pn53x_usb_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, co
 
   uint8_t abtRxBuf[PN53X_USB_BUFFER_LEN];
   if ((res = pn53x_usb_bulk_read (DRIVER_DATA (pnd), abtRxBuf, sizeof (abtRxBuf), timeout)) < 0) {
-    pnd->last_error = res;
     // try to interrupt current device state
     pn53x_usb_ack(pnd);
+    pnd->last_error = res;
     return pnd->last_error;
   }
 
@@ -551,9 +551,9 @@ read:
   }
 
   if (res < 0) {
-    pnd->last_error = res;
     // try to interrupt current device state
     pn53x_usb_ack(pnd);
+    pnd->last_error = res;
     return pnd->last_error;
   }
 
diff --git a/libnfc/nfc.c b/libnfc/nfc.c
index 5a82ab6..1038fff 100644
--- a/libnfc/nfc.c
+++ b/libnfc/nfc.c
@@ -86,9 +86,12 @@ const struct nfc_driver *nfc_drivers[] = {
 #  if defined (DRIVER_PN53X_USB_ENABLED)
   &pn53x_usb_driver,
 #  endif /* DRIVER_PN53X_USB_ENABLED */
-#  if defined (DRIVER_ACR122_ENABLED)
-  &acr122_driver,
-#  endif /* DRIVER_ACR122_ENABLED */
+#  if defined (DRIVER_ACR122_PCSC_ENABLED)
+  &acr122_pcsc_driver,
+#  endif /* DRIVER_ACR122_PCSC_ENABLED */
+#  if defined (DRIVER_ACR122_USB_ENABLED)
+  &acr122_usb_driver,
+#  endif /* DRIVER_ACR122_USB_ENABLED */
 #  if defined (DRIVER_ACR122S_ENABLED)
   &acr122s_driver,
 #  endif /* DRIVER_ACR122S_ENABLED */
diff --git a/m4/libnfc_drivers.m4 b/m4/libnfc_drivers.m4
index fb49f6c..c7af72e 100644
--- a/m4/libnfc_drivers.m4
+++ b/m4/libnfc_drivers.m4
@@ -4,7 +4,7 @@ AC_DEFUN([LIBNFC_ARG_WITH_DRIVERS],
 [
   AC_MSG_CHECKING(which drivers to build)
   AC_ARG_WITH(drivers,
-  AC_HELP_STRING([--with-drivers=DRIVERS], [Use a custom driver set, where DRIVERS is a coma-separated list of drivers to build support for. Available drivers are: 'acr122', 'acr122s', 'arygon', 'pn532_uart' and 'pn53x_usb'. Default drivers set is 'acr122,acr122s,arygon,pn53x_usb'. The special driver set 'all' compile all available drivers.]),
+  AC_HELP_STRING([--with-drivers=DRIVERS], [Use a custom driver set, where DRIVERS is a coma-separated list of drivers to build support for. Available drivers are: 'acr122_pcsc', 'acr122_usb', 'acr122s', 'arygon', 'pn532_uart' and 'pn53x_usb'. Default drivers set is 'acr122_usb,acr122s,arygon,pn53x_usb'. The special driver set 'all' compile all available drivers.]),
   [       case "${withval}" in
           yes | no)
                   dnl ignore calls without any arguments
@@ -25,16 +25,17 @@ AC_DEFUN([LIBNFC_ARG_WITH_DRIVERS],
   
   case "${DRIVER_BUILD_LIST}" in
     default)
-                  DRIVER_BUILD_LIST="acr122 acr122s arygon pn53x_usb"
+                  DRIVER_BUILD_LIST="acr122_usb acr122s arygon pn53x_usb"
                   ;;
     all)
-                  DRIVER_BUILD_LIST="acr122 acr122s arygon pn53x_usb pn532_uart"
+                  DRIVER_BUILD_LIST="acr122_pcsc acr122_usb acr122s arygon pn53x_usb pn532_uart"
                   ;;
   esac
   
   DRIVERS_CFLAGS=""
 
-  driver_acr122_enabled="no"
+  driver_acr122_pcsc_enabled="no"
+  driver_acr122_usb_enabled="no"
   driver_acr122s_enabled="no"
   driver_pn53x_usb_enabled="no"
   driver_arygon_enabled="no"
@@ -43,10 +44,15 @@ AC_DEFUN([LIBNFC_ARG_WITH_DRIVERS],
   for driver in ${DRIVER_BUILD_LIST}
   do
     case "${driver}" in
-    acr122)
+    acr122_pcsc)
                   pcsc_required="yes"
-		  driver_acr122_enabled="yes"
-                  DRIVERS_CFLAGS="$DRIVERS_CFLAGS -DDRIVER_ACR122_ENABLED"
+                  driver_acr122_pcsc_enabled="yes"
+                  DRIVERS_CFLAGS="$DRIVERS_CFLAGS -DDRIVER_ACR122_PCSC_ENABLED"
+                  ;;
+    acr122_usb)
+                  libusb_required="yes"
+                  driver_acr122_usb_enabled="yes"
+                  DRIVERS_CFLAGS="$DRIVERS_CFLAGS -DDRIVER_ACR122_USB_ENABLED"
                   ;;
     acr122s)
                   driver_acr122s_enabled="yes"
@@ -54,7 +60,7 @@ AC_DEFUN([LIBNFC_ARG_WITH_DRIVERS],
                   ;;
     pn53x_usb)
                   libusb_required="yes"
-		  driver_pn53x_usb_enabled="yes"
+                  driver_pn53x_usb_enabled="yes"
                   DRIVERS_CFLAGS="$DRIVERS_CFLAGS -DDRIVER_PN53X_USB_ENABLED"
                   ;;
     arygon)
@@ -71,7 +77,8 @@ AC_DEFUN([LIBNFC_ARG_WITH_DRIVERS],
     esac
   done
   AC_SUBST(DRIVERS_CFLAGS)
-  AM_CONDITIONAL(DRIVER_ACR122_ENABLED, [test x"$driver_acr122_enabled" = xyes])
+  AM_CONDITIONAL(DRIVER_ACR122_PCSC_ENABLED, [test x"$driver_acr122_pcsc_enabled" = xyes])
+  AM_CONDITIONAL(DRIVER_ACR122_USB_ENABLED, [test x"$driver_acr122_usb_enabled" = xyes])
   AM_CONDITIONAL(DRIVER_ACR122S_ENABLED, [test x"$driver_acr122s_enabled" = xyes])
   AM_CONDITIONAL(DRIVER_PN53X_USB_ENABLED, [test x"$driver_pn53x_usb_enabled" = xyes])
   AM_CONDITIONAL(DRIVER_ARYGON_ENABLED, [test x"$driver_arygon_enabled" = xyes])
@@ -81,7 +88,8 @@ AC_DEFUN([LIBNFC_ARG_WITH_DRIVERS],
 AC_DEFUN([LIBNFC_DRIVERS_SUMMARY],[
 echo
 echo "Selected drivers:"
-echo "   acr122........... $driver_acr122_enabled"
+echo "   acr122_pcsc...... $driver_acr122_pcsc_enabled"
+echo "   acr122_usb....... $driver_acr122_usb_enabled"
 echo "   acr122s.......... $driver_acr122s_enabled"
 echo "   arygon........... $driver_arygon_enabled"
 echo "   pn53x_usb........ $driver_pn53x_usb_enabled"
diff --git a/utils/nfc-probe.c b/utils/nfc-probe.c
index 8f8928f..71f69a5 100644
--- a/utils/nfc-probe.c
+++ b/utils/nfc-probe.c
@@ -97,19 +97,23 @@ main (int argc, const char *argv[])
   nfc_connstring connstrings[MAX_DEVICE_COUNT];
   size_t szDeviceFound = nfc_list_devices (NULL, connstrings, MAX_DEVICE_COUNT);
 
+  int res = EXIT_FAILURE;
   if (szDeviceFound == 0) {
     printf ("No NFC device found.\n");
+    goto bye;
   }
 
-  printf ("%d NFC device(s) found:\n", (int) szDeviceFound);
+  printf ("%d NFC device(s) found:\n", (int)szDeviceFound);
   for (i = 0; i < szDeviceFound; i++) {
     pnd = nfc_open (NULL, connstrings[i]);
     if (pnd != NULL) {
       printf ("- %s:\n    %s\n", nfc_device_get_name (pnd), nfc_device_get_connstring (pnd));
+      nfc_close (pnd);
     }
-    nfc_close (pnd);
   }
-  
+  res = EXIT_SUCCESS;
+
+bye:
   nfc_exit (NULL);
-  return 0;
+  return res;
 }