From: roel@libnfc.org <roel@libnfc.org@ef4ab9da-24cd-11de-8aaa-f3a34680c41f>
Date: Wed, 5 Dec 2012 16:14:10 +0000 (+0000)
Subject: removed all old usb calls
X-Git-Tag: v1.0.0~130^2~29
X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/commitdiff_plain/6e82300ddab2bf70a224b29cc3930f8cd9b92956

removed all old usb calls
---

diff --git a/armsrc/Makefile b/armsrc/Makefile
index 813db17f..47d56a2e 100644
--- a/armsrc/Makefile
+++ b/armsrc/Makefile
@@ -27,7 +27,6 @@ THUMBSRC = start.c \
 	appmain.c printf.c \
 	util.c \
 	string.c \
-	usb.c \
 	usb_cdc.c \
 	cmd.c
 
diff --git a/armsrc/appmain.c b/armsrc/appmain.c
index e501dfdd..a7c830fa 100644
--- a/armsrc/appmain.c
+++ b/armsrc/appmain.c
@@ -387,8 +387,9 @@ void SamyRun()
 
 	for (;;)
 	{
-		UsbPoll(FALSE);
-		WDT_HIT();
+//		UsbPoll(FALSE);
+		usb_poll();
+    WDT_HIT();
 
 		// Was our button held down or pressed?
 		int button_pressed = BUTTON_HELD(1000);
@@ -905,7 +906,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
 		case CMD_SETUP_WRITE:
 		case CMD_FINISH_WRITE:
 		case CMD_HARDWARE_RESET: {
-			USB_D_PLUS_PULLUP_OFF();
+      usb_disable();
 			SpinDelay(1000);
 			SpinDelay(1000);
 			AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
@@ -918,7 +919,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
 			if(common_area.flags.bootrom_present) {
 				common_area.command = COMMON_AREA_COMMAND_ENTER_FLASH_MODE;
 			}
-			USB_D_PLUS_PULLUP_OFF();
+      usb_disable();
 			AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
 			for(;;);
         } break;
@@ -955,7 +956,6 @@ void  __attribute__((noreturn)) AppMain(void)
 
   // Init USB device
   usb_enable();
-  UsbStart();
 //	UsbStart();
 
 	// The FPGA gets its clock from us from PCK0 output, so set that up.
diff --git a/armsrc/apps.h b/armsrc/apps.h
index c2b24eea..94bc5b04 100644
--- a/armsrc/apps.h
+++ b/armsrc/apps.h
@@ -181,6 +181,10 @@ void SnoopHitag(uint32_t type);
 void SimulateHitagTag(bool tag_mem_supplied, byte_t* data);
 void ReaderHitag(hitag_function htf, hitag_data* htd);
 
+// cmd.h
+bool cmd_receive(UsbCommand* cmd);
+bool cmd_send(uint32_t cmd, uint32_t arg0, uint32_t arg1, uint32_t arg2, byte_t* data, size_t len);
+
 /// util.h
 
 #endif
diff --git a/armsrc/mifarecmd.c b/armsrc/mifarecmd.c
index f18b75a0..e7850b3f 100644
--- a/armsrc/mifarecmd.c
+++ b/armsrc/mifarecmd.c
@@ -78,11 +78,12 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
 	memset(uid, 0x44, 4);
 	LogTrace(uid, 4, 0, 0, TRUE);
 
-	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
-	memcpy(ack.d.asBytes, dataoutbuf, 16);
+//	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
+//	memcpy(ack.d.asBytes, dataoutbuf, 16);
 	
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,isOK,0,0,0,0);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
 	LED_B_OFF();
 
 
@@ -170,17 +171,18 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
 	memset(uid, 0x44, 4);
 	LogTrace(uid, 4, 0, 0, TRUE);
 
-	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
-	memcpy(ack.d.asBytes, dataoutbuf, 16 * 2);
+//	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
+//	memcpy(ack.d.asBytes, dataoutbuf, 16 * 2);
 	
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
-
-	SpinDelay(100);
+  cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,32);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+//	SpinDelay(100);
 	
-	memcpy(ack.d.asBytes, dataoutbuf + 16 * 2, 16 * 2);
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
-	LED_B_OFF();	
+//	memcpy(ack.d.asBytes, dataoutbuf + 16 * 2, 16 * 2);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,isOK,0,0,dataoutbuf+32, 32);
+	LED_B_OFF();
 
 	// Thats it...
 	FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
@@ -256,11 +258,12 @@ void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
 	memset(uid, 0x44, 4);
 	LogTrace(uid, 4, 0, 0, TRUE);
 
-	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
+//	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
 	
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
-	LED_B_OFF();	
+  cmd_send(CMD_ACK,isOK,0,0,0,0);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+	LED_B_OFF();
 
 
 	// Thats it...
@@ -301,7 +304,6 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
 	nestedVector nvector[NES_MAX_INFO + 1][11];
 	int nvectorcount[NES_MAX_INFO + 1];
 	int ncount = 0;
-	UsbCommand ack = {CMD_ACK, {0, 0, 0}};
 	struct Crypto1State mpcs = {0, 0};
 	struct Crypto1State *pcs;
 	pcs = &mpcs;
@@ -468,6 +470,8 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
 	memset(uid, 0x44, 4);
 	LogTrace(uid, 4, 0, 0, TRUE);
 
+//  UsbCommand ack = {CMD_ACK, {0, 0, 0}};
+
 	for (i = 0; i < NES_MAX_INFO; i++) {
 		if (nvectorcount[i] > 10) continue;
 		
@@ -475,34 +479,38 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
 			ncount = nvectorcount[i] - j;
 			if (ncount > 5) ncount = 5; 
 
-			ack.arg[0] = 0; // isEOF = 0
-			ack.arg[1] = ncount;
-			ack.arg[2] = targetBlockNo + (targetKeyType * 0x100);
-			memset(ack.d.asBytes, 0x00, sizeof(ack.d.asBytes));
+//			ack.arg[0] = 0; // isEOF = 0
+//			ack.arg[1] = ncount;
+//			ack.arg[2] = targetBlockNo + (targetKeyType * 0x100);
+//			memset(ack.d.asBytes, 0x00, sizeof(ack.d.asBytes));
 			
-			memcpy(ack.d.asBytes, &cuid, 4);
+      byte_t buf[48];
+      memset(buf, 0x00, sizeof(buf));
+			memcpy(buf, &cuid, 4);
 			for (m = 0; m < ncount; m++) {
-				memcpy(ack.d.asBytes + 8 + m * 8 + 0, &nvector[i][m + j].nt, 4);
-				memcpy(ack.d.asBytes + 8 + m * 8 + 4, &nvector[i][m + j].ks1, 4);
+				memcpy(buf + 8 + m * 8 + 0, &nvector[i][m + j].nt, 4);
+				memcpy(buf + 8 + m * 8 + 4, &nvector[i][m + j].ks1, 4);
 			}
 	
 			LED_B_ON();
-			SpinDelay(100);
-			UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
-			LED_B_OFF();	
+//			SpinDelay(100);
+      cmd_send(CMD_ACK,0,ncount,targetBlockNo + (targetKeyType * 0x100),buf,48);
+//			UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+			LED_B_OFF();
 		}
 	}
 
 	// finalize list
-	ack.arg[0] = 1; // isEOF = 1
-	ack.arg[1] = 0;
-	ack.arg[2] = 0;
-	memset(ack.d.asBytes, 0x00, sizeof(ack.d.asBytes));
+//	ack.arg[0] = 1; // isEOF = 1
+//	ack.arg[1] = 0;
+//	ack.arg[2] = 0;
+//	memset(ack.d.asBytes, 0x00, sizeof(ack.d.asBytes));
 	
 	LED_B_ON();
-	SpinDelay(300);
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
-	LED_B_OFF();	
+//	SpinDelay(300);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,1,0,0,0,0);
+	LED_B_OFF();
 
 	if (MF_DBGLEVEL >= 4)	DbpString("NESTED FINISHED");
 
@@ -575,11 +583,12 @@ void MifareChkKeys(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
 	memset(uid, 0x44, 4);
 	LogTrace(uid, 4, 0, 0, TRUE);
 
-	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
-	if (isOK) memcpy(ack.d.asBytes, datain + i * 6, 6);
+//	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
+//	if (isOK) memcpy(ack.d.asBytes, datain + i * 6, 6);
 	
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+    cmd_send(CMD_ACK,isOK,0,0,datain + i * 6,6);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
 	LED_B_OFF();
 
   // Thats it...
@@ -612,12 +621,14 @@ void MifareEMemSet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
 }
 
 void MifareEMemGet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){
-	UsbCommand ack = {CMD_ACK, {arg0, arg1, 0}};
+//	UsbCommand ack = {CMD_ACK, {arg0, arg1, 0}};
 
-	emlGetMem(ack.d.asBytes, arg0, arg1); // data, block num, blocks count
+  byte_t buf[48];
+	emlGetMem(buf, arg0, arg1); // data, block num, blocks count
 
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,arg0,arg1,0,buf,48);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
 	LED_B_OFF();
 }
 
@@ -848,15 +859,16 @@ void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
 		break;
 	}
 	
-	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
-	if (isOK) memcpy(ack.d.asBytes, uid, 4);
+//	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
+//	if (isOK) memcpy(ack.d.asBytes, uid, 4);
 	
 	// add trace trailer
 	memset(uid, 0x44, 4);
 	LogTrace(uid, 4, 0, 0, TRUE);
 
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,isOK,0,0,uid,4);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
 	LED_B_OFF();
 
 	if ((workFlags & 0x10) || (!isOK)) {
@@ -938,15 +950,16 @@ void MifareCGetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
 		break;
 	}
 	
-	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
-	if (isOK) memcpy(ack.d.asBytes, data, 18);
+//	UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};
+//	if (isOK) memcpy(ack.d.asBytes, data, 18);
 	
 	// add trace trailer
 	memset(data, 0x44, 4);
 	LogTrace(data, 4, 0, 0, TRUE);
 
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,isOK,0,0,data,18);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
 	LED_B_OFF();
 
 	if ((workFlags & 0x10) || (!isOK)) {
diff --git a/armsrc/mifaresniff.c b/armsrc/mifaresniff.c
index 45878000..f95ca3df 100644
--- a/armsrc/mifaresniff.c
+++ b/armsrc/mifaresniff.c
@@ -31,10 +31,11 @@ int MfSniffInit(void){
 }
 
 int MfSniffEnd(void){
-	UsbCommand ack = {CMD_ACK, {0, 0, 0}};
+//	UsbCommand ack = {CMD_ACK, {0, 0, 0}};
 
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,0,0,0,0,0);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
 	LED_B_OFF();
 
 	return 0;
@@ -167,22 +168,24 @@ int intMfSniffSend() {
 
 	while (pckLen > 0) {
 		pckSize = MIN(32, pckLen);
-		UsbCommand ack = {CMD_ACK, {1, pckSize, pckNum}};
-		memcpy(ack.d.asBytes, trace + traceLen - pckLen, pckSize);
+//		UsbCommand ack = {CMD_ACK, {1, pckSize, pckNum}};
+//		memcpy(ack.d.asBytes, trace + traceLen - pckLen, pckSize);
 	
 		LED_B_ON();
-		UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
-		SpinDelay(20);
+    cmd_send(CMD_ACK,1,pckSize,pckNum,trace + traceLen - pckLen,pckSize);
+//		UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+//		SpinDelay(20);
 		LED_B_OFF();
 
 		pckLen -= pckSize;
 		pckNum++;
 	}
 
-	UsbCommand ack = {CMD_ACK, {2, 0, 0}};
+//	UsbCommand ack = {CMD_ACK, {2, 0, 0}};
 
 	LED_B_ON();
-	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
+  cmd_send(CMD_ACK,2,0,0,0,0);
+//	UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
 	LED_B_OFF();
 
 	traceLen = 0;
diff --git a/armsrc/usb_cdc.c b/armsrc/usb_cdc.c
index c3975f1d..85c5d493 100644
--- a/armsrc/usb_cdc.c
+++ b/armsrc/usb_cdc.c
@@ -33,6 +33,7 @@
  */
 
 #include "usb_cdc.h"
+#include "util.h"
 
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
@@ -215,12 +216,26 @@ byte_t btConfiguration = 0;
 byte_t btConnection    = 0;
 byte_t btReceiveBank   = AT91C_UDP_RX_DATA_BK0;
 
+//*----------------------------------------------------------------------------
+//* \fn    AT91F_USB_Disable
+//* \brief This function deactivates the USB device
+//*----------------------------------------------------------------------------
+void usb_disable() {
+  // Disconnect and reconnect USB controller for 100ms
+  AT91C_BASE_PIOA->PIO_ODR = AT91C_PIO_PA24;
+  SpinDelay(100);
+  
+  // Clear all lingering interrupts
+  if(pUdp->UDP_ISR & AT91C_UDP_ENDBUSRES) {
+    pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES;
+  }
+}
+
 //*----------------------------------------------------------------------------
 //* \fn    AT91F_USB_Enable
 //* \brief This function Activates the USB device
 //*----------------------------------------------------------------------------
-void usb_enable()
-{
+void usb_enable() {
   // Set the PLL USB Divider
   AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1 ;
   
@@ -236,14 +251,23 @@ void usb_enable()
   
   // Clear for set the Pul up resistor
 	AT91C_BASE_PIOA->PIO_CODR = AT91C_PIO_PA16;
+  
+  // Disconnect and USB device
+  usb_disable();
+  
+  // Wait for a short while
+  SpinDelay(100);
+
+  // Reconnect USB reconnect
+  AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA24;
+  AT91C_BASE_PIOA->PIO_OER = AT91C_PIO_PA24;
 }
 
 //*----------------------------------------------------------------------------
 //* \fn    AT91F_UDP_IsConfigured
 //* \brief Test if the device is configured and handle enumeration
 //*----------------------------------------------------------------------------
-bool usb_check()
-{
+bool usb_check() {
 	AT91_REG isr = pUdp->UDP_ISR;
 
 	if (isr & AT91C_UDP_ENDBUSRES) {
@@ -274,8 +298,7 @@ bool usb_poll()
 //* \fn    AT91F_UDP_Read
 //* \brief Read available data from Endpoint OUT
 //*----------------------------------------------------------------------------
-uint32_t usb_read(byte_t* data, size_t len)
-{
+uint32_t usb_read(byte_t* data, size_t len) {
   byte_t bank = btReceiveBank;
 	uint32_t packetSize, nbBytesRcv = 0;
   uint32_t time_out = 0;
@@ -308,8 +331,7 @@ uint32_t usb_read(byte_t* data, size_t len)
 //* \fn    AT91F_CDC_Write
 //* \brief Send through endpoint 2
 //*----------------------------------------------------------------------------
-uint32_t usb_write(const byte_t* data, const size_t len)
-{
+uint32_t usb_write(const byte_t* data, const size_t len) {
   size_t length = len;
 	uint32_t cpt = 0;
 
@@ -354,8 +376,7 @@ uint32_t usb_write(const byte_t* data, const size_t len)
 unsigned int csrTab[100];
 unsigned char csrIdx = 0;
 
-static void AT91F_USB_SendData(AT91PS_UDP pUdp, const char *pData, uint32_t length)
-{
+static void AT91F_USB_SendData(AT91PS_UDP pUdp, const char *pData, uint32_t length) {
 	uint32_t cpt = 0;
 	AT91_REG csr;
 
@@ -394,8 +415,7 @@ static void AT91F_USB_SendData(AT91PS_UDP pUdp, const char *pData, uint32_t leng
 //* \fn    AT91F_USB_SendZlp
 //* \brief Send zero length packet through the control endpoint
 //*----------------------------------------------------------------------------
-void AT91F_USB_SendZlp(AT91PS_UDP pUdp)
-{
+void AT91F_USB_SendZlp(AT91PS_UDP pUdp) {
 	pUdp->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
 	while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP) );
 	pUdp->UDP_CSR[0] &= ~(AT91C_UDP_TXCOMP);
@@ -406,8 +426,7 @@ void AT91F_USB_SendZlp(AT91PS_UDP pUdp)
 //* \fn    AT91F_USB_SendStall
 //* \brief Stall the control endpoint
 //*----------------------------------------------------------------------------
-void AT91F_USB_SendStall(AT91PS_UDP pUdp)
-{
+void AT91F_USB_SendStall(AT91PS_UDP pUdp) {
 	pUdp->UDP_CSR[0] |= AT91C_UDP_FORCESTALL;
 	while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_ISOERROR) );
 	pUdp->UDP_CSR[0] &= ~(AT91C_UDP_FORCESTALL | AT91C_UDP_ISOERROR);
@@ -418,8 +437,7 @@ void AT91F_USB_SendStall(AT91PS_UDP pUdp)
 //* \fn    AT91F_CDC_Enumerate
 //* \brief This function is a callback invoked when a SETUP packet is received
 //*----------------------------------------------------------------------------
-void AT91F_CDC_Enumerate()
-{
+void AT91F_CDC_Enumerate() {
 	byte_t bmRequestType, bRequest;
 	uint16_t wValue, wIndex, wLength, wStatus;
 
diff --git a/armsrc/usb_cdc.h b/armsrc/usb_cdc.h
index 8a5cd6bd..d7b9c2e5 100644
--- a/armsrc/usb_cdc.h
+++ b/armsrc/usb_cdc.h
@@ -37,6 +37,7 @@
 
 #include <common.h>
 
+void usb_disable();
 void usb_enable();
 bool usb_check();
 bool usb_poll();
diff --git a/bootrom/Makefile b/bootrom/Makefile
index 8029b6fc..e2dc0dbd 100644
--- a/bootrom/Makefile
+++ b/bootrom/Makefile
@@ -8,7 +8,7 @@
 
 # DO NOT use thumb mode in the phase 1 bootloader since that generates a section with glue code
 ARMSRC = 
-THUMBSRC = usb.c bootrom.c
+THUMBSRC = usb_hid.c bootrom.c
 ASMSRC = ram-reset.s flash-reset.s
 
 ## There is a strange bug with the linker: Sometimes it will not emit the glue to call
diff --git a/bootrom/bootrom.c b/bootrom/bootrom.c
index 0359832c..fc1c8a2c 100644
--- a/bootrom/bootrom.c
+++ b/bootrom/bootrom.c
@@ -7,6 +7,7 @@
 //-----------------------------------------------------------------------------
 
 #include <proxmark3.h>
+#include "usb_hid.h"
 
 struct common_area common_area __attribute__((section(".commonarea")));
 unsigned int start_addr, end_addr, bootrom_unlocked;
diff --git a/bootrom/usb_hid.c b/bootrom/usb_hid.c
new file mode 100644
index 00000000..189b4092
--- /dev/null
+++ b/bootrom/usb_hid.c
@@ -0,0 +1,524 @@
+//-----------------------------------------------------------------------------
+// Jonathan Westhues, split Aug 14 2005
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// The common USB driver used for both the bootloader and the application.
+//-----------------------------------------------------------------------------
+
+#include "proxmark3.h"
+#include "usb_hid.h"
+
+#define min(a, b) (((a) > (b)) ? (b) : (a))
+
+#define USB_REPORT_PACKET_SIZE 64
+
+typedef struct PACKED {
+	uint8_t		bmRequestType;
+	uint8_t		bRequest;
+	uint16_t	wValue;
+	uint16_t	wIndex;
+	uint16_t	wLength;
+} UsbSetupData;
+
+#define USB_REQUEST_GET_STATUS					0
+#define USB_REQUEST_CLEAR_FEATURE				1
+#define USB_REQUEST_SET_FEATURE					3
+#define USB_REQUEST_SET_ADDRESS					5
+#define USB_REQUEST_GET_DESCRIPTOR				6
+#define USB_REQUEST_SET_DESCRIPTOR				7
+#define USB_REQUEST_GET_CONFIGURATION			8
+#define USB_REQUEST_SET_CONFIGURATION			9
+#define USB_REQUEST_GET_INTERFACE				10
+#define USB_REQUEST_SET_INTERFACE				11
+#define USB_REQUEST_SYNC_FRAME					12
+
+#define USB_DESCRIPTOR_TYPE_DEVICE				1
+#define USB_DESCRIPTOR_TYPE_CONFIGURATION		2
+#define USB_DESCRIPTOR_TYPE_STRING				3
+#define USB_DESCRIPTOR_TYPE_INTERFACE			4
+#define USB_DESCRIPTOR_TYPE_ENDPOINT			5
+#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER	6
+#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONF	7
+#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER		8
+#define USB_DESCRIPTOR_TYPE_HID					0x21
+#define USB_DESCRIPTOR_TYPE_HID_REPORT			0x22
+
+#define USB_DEVICE_CLASS_HID					0x03
+
+static const uint8_t HidReportDescriptor[] = {
+	0x06,0xA0,0xFF,	// Usage Page (vendor defined) FFA0
+	0x09,0x01,		// Usage (vendor defined)
+	0xA1,0x01,	 	// Collection (Application)
+	0x09,0x02,   	// Usage (vendor defined)
+	0xA1,0x00,   	// Collection (Physical)
+	0x06,0xA1,0xFF,	// Usage Page (vendor defined)
+
+	//The,input report
+	0x09,0x03,   	// usage - vendor defined
+	0x09,0x04,   	// usage - vendor defined
+	0x15,0x80,   	// Logical Minimum (-128)
+	0x25,0x7F,   	// Logical Maximum (127)
+	0x35,0x00,   	// Physical Minimum (0)
+	0x45,0xFF,   	// Physical Maximum (255)
+	0x75,0x08,   	// Report Size (8)  (bits)
+	0x95,0x40,   	// Report Count (64)  (fields)
+	0x81,0x02,   	// Input (Data,Variable,Absolute)
+
+	//The,output report
+	0x09,0x05,   	// usage - vendor defined
+	0x09,0x06,   	// usage - vendor defined
+	0x15,0x80,   	// Logical Minimum (-128)
+	0x25,0x7F,   	// Logical Maximum (127)
+	0x35,0x00,   	// Physical Minimum (0)
+	0x45,0xFF,   	// Physical Maximum (255)
+	0x75,0x08,   	// Report Size (8)  (bits)
+	0x95,0x40,   	// Report Count (64)  (fields)
+	0x91,0x02,   	// Output (Data,Variable,Absolute)
+
+	0xC0,			// End Collection
+
+	0xC0,			// End Collection
+};
+
+static const uint8_t DeviceDescriptor[] = {
+	0x12,			// Descriptor length (18 bytes)
+	0x01,			// Descriptor type (Device)
+	0x10,0x01,		// Complies with USB Spec. Release (0110h = release 1.10)
+	0x00,			// Class code (0)
+	0x00,			// Subclass code (0)
+	0x00,			// Protocol (No specific protocol)
+	0x08,			// Maximum packet size for Endpoint 0 (8 bytes)
+	0xc4,0x9a,		// Vendor ID (random numbers)
+	0x8f,0x4b,		// Product ID (random numbers)
+	0x01,0x00,		// Device release number (0001)
+	0x01,			// Manufacturer string descriptor index
+	0x02,			// Product string descriptor index
+	0x03,			// Serial Number string descriptor index
+	0x01,			// Number of possible configurations (1)
+};
+
+static const uint8_t ConfigurationDescriptor[] = {
+	0x09,			// Descriptor length (9 bytes)
+	0x02,			// Descriptor type (Configuration)
+	0x29,0x00,		// Total data length (41 bytes)
+	0x01,			// Interface supported (1)
+	0x01,			// Configuration value (1)
+	0x00,			// Index of string descriptor (None)
+	0x80,			// Configuration (Bus powered)
+	250,			// Maximum power consumption (500mA)
+
+	//interface
+	0x09,			// Descriptor length (9 bytes)
+	0x04,			// Descriptor type (Interface)
+	0x00,			// Number of interface (0)
+	0x00,			// Alternate setting (0)
+	0x02,			// Number of interface endpoint (2)
+	0x03,			// Class code (HID)
+	0x00,			// Subclass code ()
+	0x00,			// Protocol code ()
+	0x00,			// Index of string()
+
+	// class
+	0x09,			// Descriptor length (9 bytes)
+	0x21,			// Descriptor type (HID)
+	0x00,0x01,		// HID class release number (1.00)
+	0x00,			// Localized country code (None)
+	0x01,			// # of HID class dscrptr to follow (1)
+	0x22,			// Report descriptor type (HID)
+	// Total length of report descriptor
+	sizeof(HidReportDescriptor),0x00,
+
+	// endpoint 1
+	0x07,			// Descriptor length (7 bytes)
+	0x05,			// Descriptor type (Endpoint)
+	0x01,			// Encoded address (Respond to OUT)
+	0x03,			// Endpoint attribute (Interrupt transfer)
+	0x08,0x00,		// Maximum packet size (8 bytes)
+	0x01,			// Polling interval (1 ms)
+
+	// endpoint 2
+	0x07,			// Descriptor length (7 bytes)
+	0x05,			// Descriptor type (Endpoint)
+	0x82,			// Encoded address (Respond to IN)
+	0x03,			// Endpoint attribute (Interrupt transfer)
+	0x08,0x00,		// Maximum packet size (8 bytes)
+	0x01,			// Polling interval (1 ms)
+};
+
+static const uint8_t StringDescriptor0[] = {
+	0x04,			// Length
+	0x03,			// Type is string
+	0x09,			// English
+	0x04,			//  US
+};
+
+static const uint8_t StringDescriptor1[] = {
+	24,				// Length
+	0x03,			// Type is string
+	'J', 0x00,
+	'.', 0x00,
+	' ', 0x00,
+	'W', 0x00,
+	'e', 0x00,
+	's', 0x00,
+	't', 0x00,
+	'h', 0x00,
+	'u', 0x00,
+	'e', 0x00,
+	's', 0x00,
+};
+
+static const uint8_t StringDescriptor2[] = {
+	54,				// Length
+	0x03,			// Type is string
+	'P', 0x00,
+	'r', 0x00,
+	'o', 0x00,
+	'x', 0x00,
+	'M', 0x00,
+	'a', 0x00,
+	'r', 0x00,
+	'k', 0x00,
+	'-', 0x00,
+	'3', 0x00,
+	' ', 0x00,
+	'R', 0x00,
+	'F', 0x00,
+	'I', 0x00,
+	'D', 0x00,
+	' ', 0x00,
+	'I', 0x00,
+	'n', 0x00,
+	's', 0x00,
+	't', 0x00,
+	'r', 0x00,
+	'u', 0x00,
+	'm', 0x00,
+	'e', 0x00,
+	'n', 0x00,
+	't', 0x00,
+};
+
+// Serial Number
+// TODO: Pick yours! Don't forget to modify the length, if needed.
+static const uint8_t StringDescriptor3[] = {
+	18,             // Length
+	0x03,           // Type is string
+	'C', 0x00,
+	'h', 0x00,
+	'a', 0x00,
+	'n', 0x00,
+	'g', 0x00,
+	'e', 0x00,
+	'M', 0x00,
+	'e', 0x00,
+};
+
+static const uint8_t * const StringDescriptors[] = {
+	StringDescriptor0,
+	StringDescriptor1,
+	StringDescriptor2,
+	StringDescriptor3,
+};
+
+
+static uint8_t UsbBuffer[64];
+static int  UsbSoFarCount;
+
+static uint8_t CurrentConfiguration;
+
+static void UsbSendEp0(const uint8_t *data, int len)
+{
+	int thisTime, i;
+
+	do {
+		thisTime = min(len, 8);
+		len -= thisTime;
+
+		for(i = 0; i < thisTime; i++) {
+			AT91C_BASE_UDP->UDP_FDR[0] = *data;
+			data++;
+		}
+
+		if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
+			AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
+			while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
+				;
+		}
+
+		AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
+
+		do {
+			if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RX_DATA_BK0) {
+				// This means that the host is trying to write to us, so
+				// abandon our write to them.
+				AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RX_DATA_BK0;
+				return;
+			}
+		} while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP));
+	} while(len > 0);
+
+	if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
+		AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
+		while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
+			;
+	}
+}
+
+static void UsbSendZeroLength(void)
+{
+	AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
+
+	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP))
+		;
+
+	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
+
+	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
+		;
+}
+
+static void UsbSendStall(void)
+{
+	AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_FORCESTALL;
+
+	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT))
+		;
+
+	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_STALLSENT;
+
+	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT)
+		;
+}
+
+static void HandleRxdSetupData(void)
+{
+	int i;
+	UsbSetupData usd;
+
+	for(i = 0; i < sizeof(usd); i++) {
+		((uint8_t *)&usd)[i] = AT91C_BASE_UDP->UDP_FDR[0];
+	}
+
+	if(usd.bmRequestType & 0x80) {
+		AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_DIR;
+		while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_DIR))
+			;
+	}
+
+	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RXSETUP;
+	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP)
+		;
+
+	switch(usd.bRequest) {
+		case USB_REQUEST_GET_DESCRIPTOR:
+			if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_DEVICE) {
+				UsbSendEp0((uint8_t *)&DeviceDescriptor,
+					min(sizeof(DeviceDescriptor), usd.wLength));
+			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_CONFIGURATION) {
+				UsbSendEp0((uint8_t *)&ConfigurationDescriptor,
+					min(sizeof(ConfigurationDescriptor), usd.wLength));
+			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_STRING) {
+				const uint8_t *s = StringDescriptors[usd.wValue & 0xff];
+				UsbSendEp0(s, min(s[0], usd.wLength));
+			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_HID_REPORT) {
+				UsbSendEp0((uint8_t *)&HidReportDescriptor,
+					min(sizeof(HidReportDescriptor), usd.wLength));
+			} else {
+				*((uint32_t *)0x00200000) = usd.wValue;
+			}
+			break;
+
+		case USB_REQUEST_SET_ADDRESS:
+			UsbSendZeroLength();
+			AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN | usd.wValue ;
+			if(usd.wValue != 0) {
+				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
+			} else {
+				AT91C_BASE_UDP->UDP_GLBSTATE = 0;
+			}
+			break;
+
+		case USB_REQUEST_GET_CONFIGURATION:
+			UsbSendEp0(&CurrentConfiguration, sizeof(CurrentConfiguration));
+			break;
+
+		case USB_REQUEST_GET_STATUS: {
+			if(usd.bmRequestType & 0x80) {
+				uint16_t w = 0;
+				UsbSendEp0((uint8_t *)&w, sizeof(w));
+			}
+			break;
+		}
+		case USB_REQUEST_SET_CONFIGURATION:
+			CurrentConfiguration = usd.wValue;
+			if(CurrentConfiguration) {
+				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;
+				AT91C_BASE_UDP->UDP_CSR[1] = AT91C_UDP_EPEDS |
+					AT91C_UDP_EPTYPE_INT_OUT;
+				AT91C_BASE_UDP->UDP_CSR[2] = AT91C_UDP_EPEDS |
+					AT91C_UDP_EPTYPE_INT_IN;
+			} else {
+				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
+				AT91C_BASE_UDP->UDP_CSR[1] = 0;
+				AT91C_BASE_UDP->UDP_CSR[2] = 0;
+			}
+			UsbSendZeroLength();
+			break;
+
+		case USB_REQUEST_GET_INTERFACE: {
+			uint8_t b = 0;
+			UsbSendEp0(&b, sizeof(b));
+			break;
+		}
+
+		case USB_REQUEST_SET_INTERFACE:
+			UsbSendZeroLength();
+			break;
+
+		case USB_REQUEST_CLEAR_FEATURE:
+		case USB_REQUEST_SET_FEATURE:
+			UsbSendStall();
+			break;
+		case USB_REQUEST_SET_DESCRIPTOR:
+		case USB_REQUEST_SYNC_FRAME:
+		default:
+			break;
+	}
+}
+
+void UsbSendPacket(uint8_t *packet, int len)
+{
+	int i, thisTime;
+
+	while(len > 0) {
+		thisTime = min(len, 8);
+
+		for(i = 0; i < thisTime; i++) {
+			AT91C_BASE_UDP->UDP_FDR[2] = packet[i];
+		}
+		AT91C_BASE_UDP->UDP_CSR[2] |= AT91C_UDP_TXPKTRDY;
+
+		while(!(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP)) {
+            WDT_HIT();
+        }
+
+		AT91C_BASE_UDP->UDP_CSR[2] &= ~AT91C_UDP_TXCOMP;
+
+		while(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP) {
+            WDT_HIT();
+        }
+
+		len -= thisTime;
+		packet += thisTime;
+	}
+}
+
+static void HandleRxdData(void)
+{
+	int i, len;
+
+	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0) {
+		len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);
+
+		for(i = 0; i < len; i++) {
+			UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
+			UsbSoFarCount++;
+		}
+
+		AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK0;
+		while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0) {
+            WDT_HIT();
+        }
+
+		if(UsbSoFarCount >= 64) {
+			UsbPacketReceived(UsbBuffer, UsbSoFarCount);
+			UsbSoFarCount = 0;
+		}
+	}
+
+	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1) {
+		len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);
+
+		for(i = 0; i < len; i++) {
+			UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
+			UsbSoFarCount++;
+		}
+
+		AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK1;
+		while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1) {
+            WDT_HIT();
+        }
+        
+		if(UsbSoFarCount >= 64) {
+			UsbPacketReceived(UsbBuffer, UsbSoFarCount);
+			UsbSoFarCount = 0;
+		}
+	}
+    
+    WDT_HIT();
+}
+
+void UsbStart(void)
+{
+	volatile int i;
+
+	UsbSoFarCount = 0;
+
+	USB_D_PLUS_PULLUP_OFF();
+
+	for(i = 0; i < 1000000; i++)
+		;
+
+	USB_D_PLUS_PULLUP_ON();
+
+	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
+		AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
+	}
+}
+
+int UsbConnected()
+{
+	if (AT91C_BASE_UDP->UDP_GLBSTATE & AT91C_UDP_CONFG)
+		return TRUE;
+	else
+		return FALSE;
+}
+
+int UsbPoll(int blinkLeds)
+{
+	int ret = FALSE;
+
+	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
+		AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
+
+		// following a reset we should be ready to receive a setup packet
+		AT91C_BASE_UDP->UDP_RSTEP = 0xf;
+		AT91C_BASE_UDP->UDP_RSTEP = 0;
+
+		AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
+
+		AT91C_BASE_UDP->UDP_CSR[0] = AT91C_UDP_EPTYPE_CTRL | AT91C_UDP_EPEDS;
+
+		CurrentConfiguration = 0;
+
+		ret = TRUE;
+	}
+
+	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(0)) {
+		if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP) {
+			HandleRxdSetupData();
+			ret = TRUE;
+		}
+	}
+
+	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(1)) {
+		HandleRxdData();
+		ret = TRUE;
+	}
+
+	return ret;
+}
diff --git a/bootrom/usb_hid.h b/bootrom/usb_hid.h
new file mode 100644
index 00000000..bbc6cec9
--- /dev/null
+++ b/bootrom/usb_hid.h
@@ -0,0 +1,29 @@
+#ifndef _USB_HID_H_
+#define _USB_HID_H_
+
+#include <common.h>
+#include <proxmark3.h>
+
+//--------------------------------
+// USB defines
+
+#define USB_D_PLUS_PULLUP_ON() { \
+HIGH(GPIO_USB_PU); \
+AT91C_BASE_PIOA->PIO_OER = GPIO_USB_PU; \
+}
+#define USB_D_PLUS_PULLUP_OFF() AT91C_BASE_PIOA->PIO_ODR = GPIO_USB_PU
+
+//--------------------------------
+// USB declarations
+
+void UsbSendPacket(uint8_t *packet, int len);
+int UsbConnected();
+int UsbPoll(int blinkLeds);
+void UsbStart(void);
+
+// This function is provided by the apps/bootrom, and called from UsbPoll
+// if data are available.
+void UsbPacketReceived(uint8_t *packet, int len);
+
+#endif // _USB_HID_H_
+
diff --git a/common/usb.c b/common/usb.c
deleted file mode 100644
index e1fc9b25..00000000
--- a/common/usb.c
+++ /dev/null
@@ -1,523 +0,0 @@
-//-----------------------------------------------------------------------------
-// Jonathan Westhues, split Aug 14 2005
-//
-// This code is licensed to you under the terms of the GNU GPL, version 2 or,
-// at your option, any later version. See the LICENSE.txt file for the text of
-// the license.
-//-----------------------------------------------------------------------------
-// The common USB driver used for both the bootloader and the application.
-//-----------------------------------------------------------------------------
-
-#include "proxmark3.h"
-
-#define min(a, b) (((a) > (b)) ? (b) : (a))
-
-#define USB_REPORT_PACKET_SIZE 64
-
-typedef struct PACKED {
-	uint8_t		bmRequestType;
-	uint8_t		bRequest;
-	uint16_t	wValue;
-	uint16_t	wIndex;
-	uint16_t	wLength;
-} UsbSetupData;
-
-#define USB_REQUEST_GET_STATUS					0
-#define USB_REQUEST_CLEAR_FEATURE				1
-#define USB_REQUEST_SET_FEATURE					3
-#define USB_REQUEST_SET_ADDRESS					5
-#define USB_REQUEST_GET_DESCRIPTOR				6
-#define USB_REQUEST_SET_DESCRIPTOR				7
-#define USB_REQUEST_GET_CONFIGURATION			8
-#define USB_REQUEST_SET_CONFIGURATION			9
-#define USB_REQUEST_GET_INTERFACE				10
-#define USB_REQUEST_SET_INTERFACE				11
-#define USB_REQUEST_SYNC_FRAME					12
-
-#define USB_DESCRIPTOR_TYPE_DEVICE				1
-#define USB_DESCRIPTOR_TYPE_CONFIGURATION		2
-#define USB_DESCRIPTOR_TYPE_STRING				3
-#define USB_DESCRIPTOR_TYPE_INTERFACE			4
-#define USB_DESCRIPTOR_TYPE_ENDPOINT			5
-#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER	6
-#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONF	7
-#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER		8
-#define USB_DESCRIPTOR_TYPE_HID					0x21
-#define USB_DESCRIPTOR_TYPE_HID_REPORT			0x22
-
-#define USB_DEVICE_CLASS_HID					0x03
-
-static const uint8_t HidReportDescriptor[] = {
-	0x06,0xA0,0xFF,	// Usage Page (vendor defined) FFA0
-	0x09,0x01,		// Usage (vendor defined)
-	0xA1,0x01,	 	// Collection (Application)
-	0x09,0x02,   	// Usage (vendor defined)
-	0xA1,0x00,   	// Collection (Physical)
-	0x06,0xA1,0xFF,	// Usage Page (vendor defined)
-
-	//The,input report
-	0x09,0x03,   	// usage - vendor defined
-	0x09,0x04,   	// usage - vendor defined
-	0x15,0x80,   	// Logical Minimum (-128)
-	0x25,0x7F,   	// Logical Maximum (127)
-	0x35,0x00,   	// Physical Minimum (0)
-	0x45,0xFF,   	// Physical Maximum (255)
-	0x75,0x08,   	// Report Size (8)  (bits)
-	0x95,0x40,   	// Report Count (64)  (fields)
-	0x81,0x02,   	// Input (Data,Variable,Absolute)
-
-	//The,output report
-	0x09,0x05,   	// usage - vendor defined
-	0x09,0x06,   	// usage - vendor defined
-	0x15,0x80,   	// Logical Minimum (-128)
-	0x25,0x7F,   	// Logical Maximum (127)
-	0x35,0x00,   	// Physical Minimum (0)
-	0x45,0xFF,   	// Physical Maximum (255)
-	0x75,0x08,   	// Report Size (8)  (bits)
-	0x95,0x40,   	// Report Count (64)  (fields)
-	0x91,0x02,   	// Output (Data,Variable,Absolute)
-
-	0xC0,			// End Collection
-
-	0xC0,			// End Collection
-};
-
-static const uint8_t DeviceDescriptor[] = {
-	0x12,			// Descriptor length (18 bytes)
-	0x01,			// Descriptor type (Device)
-	0x10,0x01,		// Complies with USB Spec. Release (0110h = release 1.10)
-	0x00,			// Class code (0)
-	0x00,			// Subclass code (0)
-	0x00,			// Protocol (No specific protocol)
-	0x08,			// Maximum packet size for Endpoint 0 (8 bytes)
-	0xc4,0x9a,		// Vendor ID (random numbers)
-	0x8f,0x4b,		// Product ID (random numbers)
-	0x01,0x00,		// Device release number (0001)
-	0x01,			// Manufacturer string descriptor index
-	0x02,			// Product string descriptor index
-	0x03,			// Serial Number string descriptor index
-	0x01,			// Number of possible configurations (1)
-};
-
-static const uint8_t ConfigurationDescriptor[] = {
-	0x09,			// Descriptor length (9 bytes)
-	0x02,			// Descriptor type (Configuration)
-	0x29,0x00,		// Total data length (41 bytes)
-	0x01,			// Interface supported (1)
-	0x01,			// Configuration value (1)
-	0x00,			// Index of string descriptor (None)
-	0x80,			// Configuration (Bus powered)
-	250,			// Maximum power consumption (500mA)
-
-	//interface
-	0x09,			// Descriptor length (9 bytes)
-	0x04,			// Descriptor type (Interface)
-	0x00,			// Number of interface (0)
-	0x00,			// Alternate setting (0)
-	0x02,			// Number of interface endpoint (2)
-	0x03,			// Class code (HID)
-	0x00,			// Subclass code ()
-	0x00,			// Protocol code ()
-	0x00,			// Index of string()
-
-	// class
-	0x09,			// Descriptor length (9 bytes)
-	0x21,			// Descriptor type (HID)
-	0x00,0x01,		// HID class release number (1.00)
-	0x00,			// Localized country code (None)
-	0x01,			// # of HID class dscrptr to follow (1)
-	0x22,			// Report descriptor type (HID)
-	// Total length of report descriptor
-	sizeof(HidReportDescriptor),0x00,
-
-	// endpoint 1
-	0x07,			// Descriptor length (7 bytes)
-	0x05,			// Descriptor type (Endpoint)
-	0x01,			// Encoded address (Respond to OUT)
-	0x03,			// Endpoint attribute (Interrupt transfer)
-	0x08,0x00,		// Maximum packet size (8 bytes)
-	0x01,			// Polling interval (1 ms)
-
-	// endpoint 2
-	0x07,			// Descriptor length (7 bytes)
-	0x05,			// Descriptor type (Endpoint)
-	0x82,			// Encoded address (Respond to IN)
-	0x03,			// Endpoint attribute (Interrupt transfer)
-	0x08,0x00,		// Maximum packet size (8 bytes)
-	0x01,			// Polling interval (1 ms)
-};
-
-static const uint8_t StringDescriptor0[] = {
-	0x04,			// Length
-	0x03,			// Type is string
-	0x09,			// English
-	0x04,			//  US
-};
-
-static const uint8_t StringDescriptor1[] = {
-	24,				// Length
-	0x03,			// Type is string
-	'J', 0x00,
-	'.', 0x00,
-	' ', 0x00,
-	'W', 0x00,
-	'e', 0x00,
-	's', 0x00,
-	't', 0x00,
-	'h', 0x00,
-	'u', 0x00,
-	'e', 0x00,
-	's', 0x00,
-};
-
-static const uint8_t StringDescriptor2[] = {
-	54,				// Length
-	0x03,			// Type is string
-	'P', 0x00,
-	'r', 0x00,
-	'o', 0x00,
-	'x', 0x00,
-	'M', 0x00,
-	'a', 0x00,
-	'r', 0x00,
-	'k', 0x00,
-	'-', 0x00,
-	'3', 0x00,
-	' ', 0x00,
-	'R', 0x00,
-	'F', 0x00,
-	'I', 0x00,
-	'D', 0x00,
-	' ', 0x00,
-	'I', 0x00,
-	'n', 0x00,
-	's', 0x00,
-	't', 0x00,
-	'r', 0x00,
-	'u', 0x00,
-	'm', 0x00,
-	'e', 0x00,
-	'n', 0x00,
-	't', 0x00,
-};
-
-// Serial Number
-// TODO: Pick yours! Don't forget to modify the length, if needed.
-static const uint8_t StringDescriptor3[] = {
-	18,             // Length
-	0x03,           // Type is string
-	'C', 0x00,
-	'h', 0x00,
-	'a', 0x00,
-	'n', 0x00,
-	'g', 0x00,
-	'e', 0x00,
-	'M', 0x00,
-	'e', 0x00,
-};
-
-static const uint8_t * const StringDescriptors[] = {
-	StringDescriptor0,
-	StringDescriptor1,
-	StringDescriptor2,
-	StringDescriptor3,
-};
-
-
-static uint8_t UsbBuffer[64];
-static int  UsbSoFarCount;
-
-static uint8_t CurrentConfiguration;
-
-static void UsbSendEp0(const uint8_t *data, int len)
-{
-	int thisTime, i;
-
-	do {
-		thisTime = min(len, 8);
-		len -= thisTime;
-
-		for(i = 0; i < thisTime; i++) {
-			AT91C_BASE_UDP->UDP_FDR[0] = *data;
-			data++;
-		}
-
-		if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
-			AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
-			while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
-				;
-		}
-
-		AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
-
-		do {
-			if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RX_DATA_BK0) {
-				// This means that the host is trying to write to us, so
-				// abandon our write to them.
-				AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RX_DATA_BK0;
-				return;
-			}
-		} while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP));
-	} while(len > 0);
-
-	if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
-		AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
-		while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
-			;
-	}
-}
-
-static void UsbSendZeroLength(void)
-{
-	AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
-
-	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP))
-		;
-
-	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
-
-	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
-		;
-}
-
-static void UsbSendStall(void)
-{
-	AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_FORCESTALL;
-
-	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT))
-		;
-
-	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_STALLSENT;
-
-	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT)
-		;
-}
-
-static void HandleRxdSetupData(void)
-{
-	int i;
-	UsbSetupData usd;
-
-	for(i = 0; i < sizeof(usd); i++) {
-		((uint8_t *)&usd)[i] = AT91C_BASE_UDP->UDP_FDR[0];
-	}
-
-	if(usd.bmRequestType & 0x80) {
-		AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_DIR;
-		while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_DIR))
-			;
-	}
-
-	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RXSETUP;
-	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP)
-		;
-
-	switch(usd.bRequest) {
-		case USB_REQUEST_GET_DESCRIPTOR:
-			if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_DEVICE) {
-				UsbSendEp0((uint8_t *)&DeviceDescriptor,
-					min(sizeof(DeviceDescriptor), usd.wLength));
-			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_CONFIGURATION) {
-				UsbSendEp0((uint8_t *)&ConfigurationDescriptor,
-					min(sizeof(ConfigurationDescriptor), usd.wLength));
-			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_STRING) {
-				const uint8_t *s = StringDescriptors[usd.wValue & 0xff];
-				UsbSendEp0(s, min(s[0], usd.wLength));
-			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_HID_REPORT) {
-				UsbSendEp0((uint8_t *)&HidReportDescriptor,
-					min(sizeof(HidReportDescriptor), usd.wLength));
-			} else {
-				*((uint32_t *)0x00200000) = usd.wValue;
-			}
-			break;
-
-		case USB_REQUEST_SET_ADDRESS:
-			UsbSendZeroLength();
-			AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN | usd.wValue ;
-			if(usd.wValue != 0) {
-				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
-			} else {
-				AT91C_BASE_UDP->UDP_GLBSTATE = 0;
-			}
-			break;
-
-		case USB_REQUEST_GET_CONFIGURATION:
-			UsbSendEp0(&CurrentConfiguration, sizeof(CurrentConfiguration));
-			break;
-
-		case USB_REQUEST_GET_STATUS: {
-			if(usd.bmRequestType & 0x80) {
-				uint16_t w = 0;
-				UsbSendEp0((uint8_t *)&w, sizeof(w));
-			}
-			break;
-		}
-		case USB_REQUEST_SET_CONFIGURATION:
-			CurrentConfiguration = usd.wValue;
-			if(CurrentConfiguration) {
-				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;
-				AT91C_BASE_UDP->UDP_CSR[1] = AT91C_UDP_EPEDS |
-					AT91C_UDP_EPTYPE_INT_OUT;
-				AT91C_BASE_UDP->UDP_CSR[2] = AT91C_UDP_EPEDS |
-					AT91C_UDP_EPTYPE_INT_IN;
-			} else {
-				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
-				AT91C_BASE_UDP->UDP_CSR[1] = 0;
-				AT91C_BASE_UDP->UDP_CSR[2] = 0;
-			}
-			UsbSendZeroLength();
-			break;
-
-		case USB_REQUEST_GET_INTERFACE: {
-			uint8_t b = 0;
-			UsbSendEp0(&b, sizeof(b));
-			break;
-		}
-
-		case USB_REQUEST_SET_INTERFACE:
-			UsbSendZeroLength();
-			break;
-
-		case USB_REQUEST_CLEAR_FEATURE:
-		case USB_REQUEST_SET_FEATURE:
-			UsbSendStall();
-			break;
-		case USB_REQUEST_SET_DESCRIPTOR:
-		case USB_REQUEST_SYNC_FRAME:
-		default:
-			break;
-	}
-}
-
-void UsbSendPacket(uint8_t *packet, int len)
-{
-	int i, thisTime;
-
-	while(len > 0) {
-		thisTime = min(len, 8);
-
-		for(i = 0; i < thisTime; i++) {
-			AT91C_BASE_UDP->UDP_FDR[2] = packet[i];
-		}
-		AT91C_BASE_UDP->UDP_CSR[2] |= AT91C_UDP_TXPKTRDY;
-
-		while(!(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP)) {
-            WDT_HIT();
-        }
-
-		AT91C_BASE_UDP->UDP_CSR[2] &= ~AT91C_UDP_TXCOMP;
-
-		while(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP) {
-            WDT_HIT();
-        }
-
-		len -= thisTime;
-		packet += thisTime;
-	}
-}
-
-static void HandleRxdData(void)
-{
-	int i, len;
-
-	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0) {
-		len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);
-
-		for(i = 0; i < len; i++) {
-			UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
-			UsbSoFarCount++;
-		}
-
-		AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK0;
-		while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0) {
-            WDT_HIT();
-        }
-
-		if(UsbSoFarCount >= 64) {
-			UsbPacketReceived(UsbBuffer, UsbSoFarCount);
-			UsbSoFarCount = 0;
-		}
-	}
-
-	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1) {
-		len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);
-
-		for(i = 0; i < len; i++) {
-			UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
-			UsbSoFarCount++;
-		}
-
-		AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK1;
-		while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1) {
-            WDT_HIT();
-        }
-        
-		if(UsbSoFarCount >= 64) {
-			UsbPacketReceived(UsbBuffer, UsbSoFarCount);
-			UsbSoFarCount = 0;
-		}
-	}
-    
-    WDT_HIT();
-}
-
-void UsbStart(void)
-{
-	volatile int i;
-
-	UsbSoFarCount = 0;
-
-	USB_D_PLUS_PULLUP_OFF();
-
-	for(i = 0; i < 1000000; i++)
-		;
-
-	USB_D_PLUS_PULLUP_ON();
-
-	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
-		AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
-	}
-}
-
-int UsbConnected()
-{
-	if (AT91C_BASE_UDP->UDP_GLBSTATE & AT91C_UDP_CONFG)
-		return TRUE;
-	else
-		return FALSE;
-}
-
-int UsbPoll(int blinkLeds)
-{
-	int ret = FALSE;
-
-	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
-		AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
-
-		// following a reset we should be ready to receive a setup packet
-		AT91C_BASE_UDP->UDP_RSTEP = 0xf;
-		AT91C_BASE_UDP->UDP_RSTEP = 0;
-
-		AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
-
-		AT91C_BASE_UDP->UDP_CSR[0] = AT91C_UDP_EPTYPE_CTRL | AT91C_UDP_EPEDS;
-
-		CurrentConfiguration = 0;
-
-		ret = TRUE;
-	}
-
-	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(0)) {
-		if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP) {
-			HandleRxdSetupData();
-			ret = TRUE;
-		}
-	}
-
-	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(1)) {
-		HandleRxdData();
-		ret = TRUE;
-	}
-
-	return ret;
-}
diff --git a/include/proxmark3.h b/include/proxmark3.h
index 0431dc80..e54da312 100644
--- a/include/proxmark3.h
+++ b/include/proxmark3.h
@@ -67,12 +67,6 @@
 
 //#define PACKED __attribute__((__packed__))
 
-#define USB_D_PLUS_PULLUP_ON() { \
-		HIGH(GPIO_USB_PU); \
-		AT91C_BASE_PIOA->PIO_OER = GPIO_USB_PU; \
-	}
-#define USB_D_PLUS_PULLUP_OFF() AT91C_BASE_PIOA->PIO_ODR = GPIO_USB_PU
-
 #define LED_A_ON()		HIGH(GPIO_LED_A)
 #define LED_A_OFF()		LOW(GPIO_LED_A)
 #define LED_A_INV()		INVBIT(GPIO_LED_A)
@@ -88,17 +82,6 @@
 #define RELAY_ON()		HIGH(GPIO_RELAY)
 #define RELAY_OFF()		LOW(GPIO_RELAY)
 #define BUTTON_PRESS()	!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_BUTTON)
-//--------------------------------
-// USB declarations
-
-void UsbSendPacket(uint8_t *packet, int len);
-int UsbConnected();
-int UsbPoll(int blinkLeds);
-void UsbStart(void);
-
-// This function is provided by the apps/bootrom, and called from UsbPoll
-// if data are available.
-void UsbPacketReceived(uint8_t *packet, int len);
 
 #define VERSION_INFORMATION_MAGIC 0x56334d50
 struct version_information {