From 27f70579611478fd277ddeb9beda91fa09117729 Mon Sep 17 00:00:00 2001
From: Philippe Teuwen <phil@teuwen.org>
Date: Tue, 30 Apr 2019 21:10:11 +0200
Subject: [PATCH] Rename few USB -> PM3 to avoid misleading interpretations

---
 armsrc/Standalone/hf_mattyrun.h               |  2 +-
 armsrc/appmain.c                              | 30 +++++++++----------
 armsrc/iclass.c                               | 12 ++++----
 armsrc/iso14443a.c                            |  2 +-
 armsrc/iso14443a.h                            |  2 +-
 armsrc/iso14443b.c                            |  4 +--
 armsrc/mifarecmd.c                            | 14 ++++-----
 armsrc/mifaredesfire.c                        |  8 ++---
 armsrc/mifaresniff.c                          |  2 +-
 bootrom/bootrom.c                             |  4 +--
 client/Makefile                               |  8 ++---
 client/cmdanalyse.c                           |  4 +--
 client/cmdhf14a.c                             | 16 +++++-----
 client/cmdhf14b.c                             |  8 ++---
 client/cmdhf15.c                              |  8 ++---
 client/cmdhfepa.c                             |  2 +-
 client/cmdhffelica.c                          |  6 ++--
 client/cmdhficlass.c                          | 10 +++----
 client/cmdhficlass.h                          |  2 +-
 client/cmdhflegic.c                           | 12 ++++----
 client/cmdhfmf.c                              |  4 +--
 client/cmdhw.c                                |  6 ++--
 client/cmdlf.c                                | 24 +++++++--------
 client/cmdlfhitag.c                           |  6 ++--
 client/cmdmain.h                              |  2 +-
 client/cmdsmartcard.c                         | 18 +++++------
 client/cmdtrace.c                             |  8 ++---
 client/comms.c                                | 20 ++++++-------
 client/comms.h                                |  2 +-
 client/flash.h                                |  2 +-
 client/flasher.c                              |  2 +-
 client/mifare/mifarehost.c                    | 12 ++++----
 .../{usb_cmd_h2lua.awk => pm3_cmd_h2lua.awk}  |  2 +-
 client/proxmark3.h                            |  2 +-
 client/scripting.c                            | 10 +++----
 client/scripting.h                            |  2 +-
 common/Makefile.common                        |  2 +-
 common/cmd.c                                  | 20 ++++++-------
 common/cmd.h                                  |  2 +-
 include/{usb_cmd.h => pm3_cmd.h}              | 24 +++++++--------
 include/proxmark3.h                           |  2 +-
 uart/uart_posix.c                             |  2 +-
 42 files changed, 165 insertions(+), 165 deletions(-)
 rename client/{usb_cmd_h2lua.awk => pm3_cmd_h2lua.awk} (85%)
 rename include/{usb_cmd.h => pm3_cmd.h} (97%)

diff --git a/armsrc/Standalone/hf_mattyrun.h b/armsrc/Standalone/hf_mattyrun.h
index c37624821..5577e298a 100644
--- a/armsrc/Standalone/hf_mattyrun.h
+++ b/armsrc/Standalone/hf_mattyrun.h
@@ -14,7 +14,7 @@
 
 #include "standalone.h" // standalone definitions
 #include "apps.h"       // debugstatements, lfops?
-#include "usb_cmd.h"    // mifare1ksim flags
+#include "pm3_cmd.h"    // mifare1ksim flags
 #include "mifaresim.h"  // mifare1ksim
 #include "mifareutil.h"
 
diff --git a/armsrc/appmain.c b/armsrc/appmain.c
index ce716f026..b81f7a70b 100644
--- a/armsrc/appmain.c
+++ b/armsrc/appmain.c
@@ -118,7 +118,7 @@ void DbpStringEx(uint32_t flags, char *str) {
 #if DEBUG
     struct {
         uint16_t flag;
-        uint8_t buf[USB_CMD_DATA_SIZE - sizeof(uint16_t)];
+        uint8_t buf[PM3_CMD_DATA_SIZE - sizeof(uint16_t)];
     } PACKED data;
     data.flag = flags;
     uint16_t len = MIN(strlen(str), sizeof(data.buf));
@@ -333,8 +333,8 @@ extern struct version_information version_information;
 /* bootrom version information is pointed to from _bootphase1_version_pointer */
 extern char *_bootphase1_version_pointer, _flash_start, _flash_end, _bootrom_start, _bootrom_end, __data_src_start__;
 void SendVersion(void) {
-    char temp[USB_CMD_DATA_SIZE]; /* Limited data payload in USB packets */
-    char VersionString[USB_CMD_DATA_SIZE] = { '\0' };
+    char temp[PM3_CMD_DATA_SIZE]; /* Limited data payload in USB packets */
+    char VersionString[PM3_CMD_DATA_SIZE] = { '\0' };
 
     /* Try to find the bootrom version information. Expect to find a pointer at
      * symbol _bootphase1_version_pointer, perform slight sanity checks on the
@@ -384,9 +384,9 @@ void printUSBSpeed(void) {
     LED_B_ON();
 
     while (end_time < start_time + USB_SPEED_TEST_MIN_TIME) {
-        reply_ng(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, PM3_SUCCESS, test_data, USB_CMD_DATA_SIZE);
+        reply_ng(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, PM3_SUCCESS, test_data, PM3_CMD_DATA_SIZE);
         end_time = GetTickCount();
-        bytes_transferred += USB_CMD_DATA_SIZE;
+        bytes_transferred += PM3_CMD_DATA_SIZE;
     }
     LED_B_OFF();
 
@@ -1089,7 +1089,7 @@ static void PacketReceived(PacketCommandNG *packet) {
         case CMD_SMART_UPLOAD: {
             // upload file from client
             uint8_t *mem = BigBuf_get_addr();
-            memcpy(mem + packet->oldarg[0], packet->data.asBytes, USB_CMD_DATA_SIZE);
+            memcpy(mem + packet->oldarg[0], packet->data.asBytes, PM3_CMD_DATA_SIZE);
             reply_old(CMD_ACK, 1, 0, 0, 0, 0);
             break;
         }
@@ -1205,8 +1205,8 @@ static void PacketReceived(PacketCommandNG *packet) {
             // arg2 = BigBuf tracelen
             //Dbprintf("transfer to client parameters: %" PRIu32 " | %" PRIu32 " | %" PRIu32, startidx, numofbytes, packet->oldarg[2]);
 
-            for (size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
-                size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
+            for (size_t i = 0; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
+                size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
                 int result = reply_old(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, i, len, BigBuf_get_traceLen(), mem + startidx + i, len);
                 if (result != PM3_SUCCESS)
                     Dbprintf("transfer to client failed ::  | bytes between %d - %d (%d) | result: %d", i, i + len, len, result);
@@ -1234,7 +1234,7 @@ static void PacketReceived(PacketCommandNG *packet) {
                 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
 
             uint8_t *mem = BigBuf_get_addr();
-            memcpy(mem + packet->oldarg[0], packet->data.asBytes, USB_CMD_DATA_SIZE);
+            memcpy(mem + packet->oldarg[0], packet->data.asBytes, PM3_CMD_DATA_SIZE);
             reply_old(CMD_ACK, 1, 0, 0, 0, 0);
             break;
         }
@@ -1249,8 +1249,8 @@ static void PacketReceived(PacketCommandNG *packet) {
             // arg1 = length bytes to transfer
             // arg2 = RFU
 
-            for (size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
-                len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
+            for (size_t i = 0; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
+                len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
                 int result = reply_old(CMD_DOWNLOADED_EML_BIGBUF, i, len, 0, mem + startidx + i, len);
                 if (result != PM3_SUCCESS)
                     Dbprintf("transfer to client failed ::  | bytes between %d - %d (%d) | result: %d", i, i + len, len, result);
@@ -1274,7 +1274,7 @@ static void PacketReceived(PacketCommandNG *packet) {
 
             Dbprintf("FlashMem read | %d - %d | ", startidx, len);
 
-            size_t size = MIN(USB_CMD_DATA_SIZE, len);
+            size_t size = MIN(PM3_CMD_DATA_SIZE, len);
 
             if (!FlashInit()) {
                 break;
@@ -1383,7 +1383,7 @@ static void PacketReceived(PacketCommandNG *packet) {
         case CMD_FLASHMEM_DOWNLOAD: {
 
             LED_B_ON();
-            uint8_t *mem = BigBuf_malloc(USB_CMD_DATA_SIZE);
+            uint8_t *mem = BigBuf_malloc(PM3_CMD_DATA_SIZE);
             uint32_t startidx = packet->oldarg[0];
             uint32_t numofbytes = packet->oldarg[1];
             // arg0 = startindex
@@ -1394,8 +1394,8 @@ static void PacketReceived(PacketCommandNG *packet) {
                 break;
             }
 
-            for (size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
-                size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
+            for (size_t i = 0; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
+                size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
 
                 bool isok = Flash_ReadDataCont(startidx + i, mem, len);
                 if (!isok)
diff --git a/armsrc/iclass.c b/armsrc/iclass.c
index 9e8dfd653..8d52ba209 100644
--- a/armsrc/iclass.c
+++ b/armsrc/iclass.c
@@ -1168,7 +1168,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
 
     //Use the emulator memory for SIM
     uint8_t *emulator = BigBuf_get_EM_addr();
-    uint8_t mac_responses[USB_CMD_DATA_SIZE] = { 0 };
+    uint8_t mac_responses[PM3_CMD_DATA_SIZE] = { 0 };
 
     if (simType == 0) {
         // Use the CSN from commandline
@@ -1188,7 +1188,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
         // in order to obtain the keys, as in the "dismantling iclass"-paper.
 #define EPURSE_MAC_SIZE 16
         int i = 0;
-        for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < USB_CMD_DATA_SIZE; i++) {
+        for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < PM3_CMD_DATA_SIZE; i++) {
             // The usb data is 512 bytes, fitting 65 8-byte CSNs in there.
 
             memcpy(emulator, datain + (i * 8), 8);
@@ -1220,7 +1220,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
         // attack below is same as SIM 2, but we run the CSN twice to collected the mac for both keys.
         int i = 0;
         // The usb data is 512 bytes, fitting 65 8-byte CSNs in there.  iceman fork uses 9 CSNS
-        for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < USB_CMD_DATA_SIZE; i++) {
+        for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < PM3_CMD_DATA_SIZE; i++) {
 
             memcpy(emulator, datain + (i * 8), 8);
 
@@ -2110,7 +2110,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *mac) {
     uint8_t mem = 0;
     uint8_t check[] = { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     uint8_t read[]  = { 0x0c, 0x00, 0x00, 0x00 };
-    uint8_t card_data[USB_CMD_DATA_SIZE] = {0};
+    uint8_t card_data[PM3_CMD_DATA_SIZE] = {0};
     uint8_t resp[ICLASS_BUFFER_SIZE] = {0};
 
     static struct memory_t {
@@ -2158,7 +2158,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *mac) {
 
         WDT_HIT();
         //Set card_data to all zeroes, we'll fill it with data
-        memset(card_data, 0x0, USB_CMD_DATA_SIZE);
+        memset(card_data, 0x0, PM3_CMD_DATA_SIZE);
         uint8_t failedRead = 0;
         uint32_t stored_data_length = 0;
 
@@ -2178,7 +2178,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *mac) {
                 //Fill up the buffer
                 memcpy(card_data + stored_data_length, resp, 8);
                 stored_data_length += 8;
-                if (stored_data_length + 8 > USB_CMD_DATA_SIZE) {
+                if (stored_data_length + 8 > PM3_CMD_DATA_SIZE) {
                     //Time to send this off and start afresh
                     reply_old(CMD_ACK,
                               stored_data_length,//data length
diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c
index 702e83e2b..2b5c3f06f 100644
--- a/armsrc/iso14443a.c
+++ b/armsrc/iso14443a.c
@@ -2406,7 +2406,7 @@ void ReaderIso14443a(PacketCommandNG *c) {
     uint32_t timeout = c->oldarg[2];
     uint8_t *cmd = c->data.asBytes;
     uint32_t arg0;
-    uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
     uint8_t par[MAX_PARITY_SIZE] = {0x00};
 
     if ((param & ISO14A_CONNECT))
diff --git a/armsrc/iso14443a.h b/armsrc/iso14443a.h
index 3c89f17af..4d898e18d 100644
--- a/armsrc/iso14443a.h
+++ b/armsrc/iso14443a.h
@@ -17,7 +17,7 @@
 extern "C" {
 #endif
 
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "cmd.h"
 #include "apps.h"
 #include "util.h"
diff --git a/armsrc/iso14443b.c b/armsrc/iso14443b.c
index 5484b435c..e72625761 100644
--- a/armsrc/iso14443b.c
+++ b/armsrc/iso14443b.c
@@ -1573,7 +1573,7 @@ void SendRawCommand14443B_Ex(PacketCommandNG *c) {
     uint8_t *cmd = c->data.asBytes;
     uint8_t status;
     uint32_t sendlen = sizeof(iso14b_card_select_t);
-    uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
 
     if (MF_DBGLEVEL > 3) Dbprintf("14b raw: param, %04x", param);
 
@@ -1621,7 +1621,7 @@ void SendRawCommand14443B_Ex(PacketCommandNG *c) {
         CodeAndTransmit14443bAsReader(cmd, len); // raw
         GetTagSamplesFor14443bDemod(); // raw
 
-        sendlen = MIN(Demod.len, USB_CMD_DATA_SIZE);
+        sendlen = MIN(Demod.len, PM3_CMD_DATA_SIZE);
         status = (Demod.len > 0) ? 0 : 1;
         reply_old(CMD_ACK, status, sendlen, 0, Demod.output, sendlen);
     }
diff --git a/armsrc/mifarecmd.c b/armsrc/mifarecmd.c
index db421954c..36510dfbf 100644
--- a/armsrc/mifarecmd.c
+++ b/armsrc/mifarecmd.c
@@ -621,7 +621,7 @@ void MifareAcquireNonces(uint32_t arg0, uint32_t arg1, uint32_t flags, uint8_t *
     uint8_t uid[10] = {0x00};
     uint8_t answer[MAX_MIFARE_FRAME_SIZE] = {0x00};
     uint8_t par[1] = {0x00};
-    uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
     uint32_t cuid = 0;
     int16_t isOK = 0;
     uint16_t num_nonces = 0;
@@ -645,7 +645,7 @@ void MifareAcquireNonces(uint32_t arg0, uint32_t arg1, uint32_t flags, uint8_t *
 
     LED_C_ON();
 
-    for (uint16_t i = 0; i <= USB_CMD_DATA_SIZE - 4; i += 4) {
+    for (uint16_t i = 0; i <= PM3_CMD_DATA_SIZE - 4; i += 4) {
 
         // Test if the action was cancelled
         if (BUTTON_PRESS()) {
@@ -733,7 +733,7 @@ void MifareAcquireEncryptedNonces(uint32_t arg0, uint32_t arg1, uint32_t flags,
     uint8_t uid[10] = {0x00};
     uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
     uint8_t par_enc[1] = {0x00};
-    uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
 
     uint64_t ui64Key = bytes_to_num(datain, 6);
     uint32_t cuid = 0;
@@ -763,7 +763,7 @@ void MifareAcquireEncryptedNonces(uint32_t arg0, uint32_t arg1, uint32_t flags,
 
     LED_C_ON();
 
-    for (uint16_t i = 0; i <= USB_CMD_DATA_SIZE - 9;) {
+    for (uint16_t i = 0; i <= PM3_CMD_DATA_SIZE - 9;) {
 
         // Test if the action was cancelled
         if (BUTTON_PRESS()) {
@@ -1645,11 +1645,11 @@ 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) {
     FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
-    uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
     emlGetMem(buf, arg0, arg1); // data, block num, blocks count (max 4)
 
     LED_B_ON();
-    reply_old(CMD_ACK, arg0, arg1, 0, buf, USB_CMD_DATA_SIZE);
+    reply_old(CMD_ACK, arg0, arg1, 0, buf, PM3_CMD_DATA_SIZE);
     LED_B_OFF();
 }
 
@@ -1949,7 +1949,7 @@ void MifareCIdent() {
     uint8_t recpar[1] = {0x00};
     uint8_t rats[4] = { ISO14443A_CMD_RATS, 0x80, 0x31, 0x73 };
     uint8_t *par = BigBuf_malloc(MAX_PARITY_SIZE);
-    uint8_t *buf = BigBuf_malloc(USB_CMD_DATA_SIZE);
+    uint8_t *buf = BigBuf_malloc(PM3_CMD_DATA_SIZE);
     uint8_t *uid = BigBuf_malloc(10);
     uint32_t cuid = 0;
 
diff --git a/armsrc/mifaredesfire.c b/armsrc/mifaredesfire.c
index 4854adc51..c152bcb9f 100644
--- a/armsrc/mifaredesfire.c
+++ b/armsrc/mifaredesfire.c
@@ -88,8 +88,8 @@ void MifareDesfireGetInformation() {
 
     int len = 0;
     iso14a_card_select_t card;
-    uint8_t resp[USB_CMD_DATA_SIZE] = {0x00};
-    uint8_t dataout[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t resp[PM3_CMD_DATA_SIZE] = {0x00};
+    uint8_t dataout[PM3_CMD_DATA_SIZE] = {0x00};
 
     /*
         1 = PCB                 1
@@ -505,7 +505,7 @@ int DesfireAPDU(uint8_t *cmd, size_t cmd_len, uint8_t *dataout) {
 
     size_t len = 0;
     size_t wrappedLen = 0;
-    uint8_t wCmd[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t wCmd[PM3_CMD_DATA_SIZE] = {0x00};
     uint8_t resp[MAX_FRAME_SIZE];
     uint8_t par[MAX_PARITY_SIZE];
 
@@ -537,7 +537,7 @@ int DesfireAPDU(uint8_t *cmd, size_t cmd_len, uint8_t *dataout) {
 // CreateAPDU
 size_t CreateAPDU(uint8_t *datain, size_t len, uint8_t *dataout) {
 
-    size_t cmdlen = MIN(len + 4, USB_CMD_DATA_SIZE - 1);
+    size_t cmdlen = MIN(len + 4, PM3_CMD_DATA_SIZE - 1);
 
     uint8_t cmd[cmdlen];
     memset(cmd, 0, cmdlen);
diff --git a/armsrc/mifaresniff.c b/armsrc/mifaresniff.c
index 5d50f55c5..790614c01 100644
--- a/armsrc/mifaresniff.c
+++ b/armsrc/mifaresniff.c
@@ -315,7 +315,7 @@ void RAMFUNC MfSniffSend() {
 
     while (packlen > 0) {
         LED_B_ON();
-        chunksize = MIN(USB_CMD_DATA_SIZE, packlen); // chunk size 512
+        chunksize = MIN(PM3_CMD_DATA_SIZE, packlen); // chunk size 512
         reply_old(CMD_ACK, 1, tracelen, chunksize, data + tracelen - packlen, chunksize);
         packlen -= chunksize;
         LED_B_OFF();
diff --git a/bootrom/bootrom.c b/bootrom/bootrom.c
index 8b1545332..7caa01360 100644
--- a/bootrom/bootrom.c
+++ b/bootrom/bootrom.c
@@ -26,9 +26,9 @@ static int reply_old(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2,
     txcmd.arg[1] = arg1;
     txcmd.arg[2] = arg2;
 
-    // Add the (optional) content to the frame, with a maximum size of USB_CMD_DATA_SIZE
+    // Add the (optional) content to the frame, with a maximum size of PM3_CMD_DATA_SIZE
     if (data && len) {
-        len = MIN(len, USB_CMD_DATA_SIZE);
+        len = MIN(len, PM3_CMD_DATA_SIZE);
         for (size_t i = 0; i < len; i++) {
             txcmd.d.asBytes[i] = ((uint8_t *)data)[i];
         }
diff --git a/client/Makefile b/client/Makefile
index d6f25156e..9b35d6df8 100644
--- a/client/Makefile
+++ b/client/Makefile
@@ -283,7 +283,7 @@ ifeq "$(SUPPORTS_AVX512)" "True"
 endif
 
 BINS = proxmark3 flasher fpga_compress
-CLEAN = $(BINS) $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(ZLIBOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(OBJDIR)/*.o *.moc.cpp ui/ui_overlays.h lualibs/usb_cmd.lua lualibs/mf_default_keys.lua
+CLEAN = $(BINS) $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(ZLIBOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(OBJDIR)/*.o *.moc.cpp ui/ui_overlays.h lualibs/pm3_cmd.lua lualibs/mf_default_keys.lua
 
 # need to assign dependancies to build these first...
 all: lua_build jansson_build mbedtls_build cbor_build $(BINS)
@@ -292,7 +292,7 @@ all-static: LDLIBS:=-static $(LDLIBS)
 all-static: proxmark3 flasher fpga_compress
 
 proxmark3: LDLIBS+=$(LUALIB) $(JANSSONLIB) $(MBEDTLSLIB) $(CBORLIB) $(QTLDLIBS)
-proxmark3: $(OBJDIR)/proxmark3.o $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(ZLIBOBJS) lualibs/usb_cmd.lua lualibs/mf_default_keys.lua
+proxmark3: $(OBJDIR)/proxmark3.o $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(ZLIBOBJS) lualibs/pm3_cmd.lua lualibs/mf_default_keys.lua
 	$(LD) $(LDFLAGS) $(OBJDIR)/proxmark3.o $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(ZLIBOBJS) $(LDLIBS)  -o $@
 
 flasher: $(OBJDIR)/flash.o $(OBJDIR)/flasher.o $(COREOBJS) $(OBJCOBJS)
@@ -309,8 +309,8 @@ proxguiqt.moc.cpp: proxguiqt.h
 ui/ui_overlays.h: ui/overlays.ui
 	$(UIC) $^ > $@
 
-lualibs/usb_cmd.lua: ../include/usb_cmd.h
-	awk -f usb_cmd_h2lua.awk $^ > $@
+lualibs/pm3_cmd.lua: ../include/pm3_cmd.h
+	awk -f pm3_cmd_h2lua.awk $^ > $@
 
 lualibs/mf_default_keys.lua : default_keys.dic
 	awk -f default_keys_dic2lua.awk $^ > $@
diff --git a/client/cmdanalyse.c b/client/cmdanalyse.c
index 2385de4e0..1b12b33fd 100644
--- a/client/cmdanalyse.c
+++ b/client/cmdanalyse.c
@@ -488,7 +488,7 @@ static int CmdAnalyseA(const char *Cmd) {
     int hexlen = 0;
     uint8_t cmdp = 0;
     bool errors = false;
-    uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
 
     while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
         switch (tolower(param_getchar(Cmd, cmdp))) {
@@ -513,7 +513,7 @@ static int CmdAnalyseA(const char *Cmd) {
 
 
     clearCommandBuffer();
-    SendCommandOLD(CMD_FPC_SEND, 0, 0, 0, data, USB_CMD_DATA_SIZE);
+    SendCommandOLD(CMD_FPC_SEND, 0, 0, 0, data, PM3_CMD_DATA_SIZE);
 
     PacketResponseNG resp;
     if (!WaitForResponseTimeout(CMD_ACK, &resp, 2500)) {
diff --git a/client/cmdhf14a.c b/client/cmdhf14a.c
index e6ad488bd..42e5e5c29 100644
--- a/client/cmdhf14a.c
+++ b/client/cmdhf14a.c
@@ -558,7 +558,7 @@ int ExchangeRAW14a(uint8_t *datain, int datainlen, bool activateField, bool leav
     if (leaveSignalON)
         cmdc |= ISO14A_NO_DISCONNECT;
 
-    uint8_t data[USB_CMD_DATA_SIZE] = { 0x0a | responseNum, 0x00};
+    uint8_t data[PM3_CMD_DATA_SIZE] = { 0x0a | responseNum, 0x00};
     responseNum ^= 1;
     memcpy(&data[2], datain, datainlen & 0xFFFF);
     SendCommandOLD(CMD_READER_ISO_14443a, ISO14A_RAW | ISO14A_APPEND_CRC | cmdc, (datainlen & 0xFFFF) + 2, 0, data, (datainlen & 0xFFFF) + 2);
@@ -688,7 +688,7 @@ static int CmdExchangeAPDU(bool chainingin, uint8_t *datain, int datainlen, bool
 
     // "Command APDU" length should be 5+255+1, but javacard's APDU buffer might be smaller - 133 bytes
     // https://stackoverflow.com/questions/32994936/safe-max-java-card-apdu-data-command-and-respond-size
-    // here length USB_CMD_DATA_SIZE=512
+    // here length PM3_CMD_DATA_SIZE=512
     // timeout must be authomatically set by "get ATS"
     if (datain)
         SendCommandOLD(CMD_READER_ISO_14443a, ISO14A_APDU | ISO14A_NO_DISCONNECT | cmdc, (datainlen & 0xFFFF), 0, datain, datainlen & 0xFFFF);
@@ -764,7 +764,7 @@ int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool lea
 
     // 3 byte here - 1b framing header, 2b crc16
     if (APDUInFramingEnable &&
-            ((frameLength && (datainlen > frameLength - 3)) || (datainlen > USB_CMD_DATA_SIZE - 3))) {
+            ((frameLength && (datainlen > frameLength - 3)) || (datainlen > PM3_CMD_DATA_SIZE - 3))) {
         int clen = 0;
 
         bool vActivateField = activateField;
@@ -828,7 +828,7 @@ int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool lea
 
 // ISO14443-4. 7. Half-duplex block transmission protocol
 static int CmdHF14AAPDU(const char *Cmd) {
-    uint8_t data[USB_CMD_DATA_SIZE];
+    uint8_t data[PM3_CMD_DATA_SIZE];
     int datalen = 0;
     bool activateField = false;
     bool leaveSignalON = false;
@@ -857,7 +857,7 @@ static int CmdHF14AAPDU(const char *Cmd) {
     CLIParserFree();
     PrintAndLogEx(NORMAL, ">>>>[%s%s%s] %s", activateField ? "sel " : "", leaveSignalON ? "keep " : "", decodeTLV ? "TLV" : "", sprint_hex(data, datalen));
 
-    int res = ExchangeAPDU14a(data, datalen, activateField, leaveSignalON, data, USB_CMD_DATA_SIZE, &datalen);
+    int res = ExchangeAPDU14a(data, datalen, activateField, leaveSignalON, data, PM3_CMD_DATA_SIZE, &datalen);
 
     if (res)
         return res;
@@ -887,7 +887,7 @@ static int CmdHF14ACmdRaw(const char *Cmd) {
     bool topazmode = false;
     char buf[5] = "";
     int i = 0;
-    uint8_t data[USB_CMD_DATA_SIZE];
+    uint8_t data[PM3_CMD_DATA_SIZE];
     uint16_t datalen = 0;
     uint32_t temp;
 
@@ -1012,8 +1012,8 @@ static int CmdHF14ACmdRaw(const char *Cmd) {
         flags |= ISO14A_NO_RATS;
     }
 
-    // Max buffer is USB_CMD_DATA_SIZE
-    datalen = (datalen > USB_CMD_DATA_SIZE) ? USB_CMD_DATA_SIZE : datalen;
+    // Max buffer is PM3_CMD_DATA_SIZE
+    datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen;
 
     clearCommandBuffer();
     SendCommandOLD(CMD_READER_ISO_14443a, flags, (datalen & 0xFFFF) | ((uint32_t)(numbits << 16)), argtimeout, data, datalen & 0xFFFF);
diff --git a/client/cmdhf14b.c b/client/cmdhf14b.c
index 3512e4860..0696a3203 100644
--- a/client/cmdhf14b.c
+++ b/client/cmdhf14b.c
@@ -121,7 +121,7 @@ static int switch_off_field_14b(void) {
 
 static bool waitCmd14b(bool verbose) {
 
-    uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
     PacketResponseNG resp;
 
     if (WaitForResponseTimeout(CMD_ACK, &resp, TIMEOUT)) {
@@ -188,7 +188,7 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
     bool reply = true, power = false, select = false, hasTimeout = false;
     char buf[5] = "";
     int i = 0;
-    uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
     uint16_t datalen = 0;
     uint32_t flags = ISO14B_CONNECT;
     uint32_t temp = 0, user_timeout = 0, time_wait = 0;
@@ -270,8 +270,8 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
     if (datalen > 0)
         flags |= ISO14B_RAW;
 
-    // Max buffer is USB_CMD_DATA_SIZE
-    datalen = (datalen > USB_CMD_DATA_SIZE) ? USB_CMD_DATA_SIZE : datalen;
+    // Max buffer is PM3_CMD_DATA_SIZE
+    datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen;
 
     clearCommandBuffer();
     SendCommandOLD(CMD_ISO_14443B_COMMAND, flags, datalen, time_wait, data, datalen);
diff --git a/client/cmdhf15.c b/client/cmdhf15.c
index 0aeccb5ea..5cce0079a 100644
--- a/client/cmdhf15.c
+++ b/client/cmdhf15.c
@@ -592,7 +592,7 @@ static int CmdHF15Info(const char *Cmd) {
 
     PacketResponseNG resp;
     uint8_t *recv;
-    uint8_t req[USB_CMD_DATA_SIZE] = {0};
+    uint8_t req[PM3_CMD_DATA_SIZE] = {0};
     uint16_t reqlen;
     uint8_t arg1 = 1;
     char cmdbuf[100] = {0};
@@ -932,7 +932,7 @@ static int CmdHF15Readmulti(const char *Cmd) {
 
     PacketResponseNG resp;
     uint8_t *recv;
-    uint8_t req[USB_CMD_DATA_SIZE] = {0};
+    uint8_t req[PM3_CMD_DATA_SIZE] = {0};
     uint16_t reqlen = 0;
     uint8_t arg1 = 1;
     uint8_t pagenum, pagecount;
@@ -1018,7 +1018,7 @@ static int CmdHF15Read(const char *Cmd) {
     // arg0 (datalen,  cmd len?  .arg0 == crc?)
     // arg1 (speed == 0 == 1 of 256,  == 1 == 1 of 4 )
     // arg2 (recv == 1 == expect a response)
-    uint8_t req[USB_CMD_DATA_SIZE] = {0};
+    uint8_t req[PM3_CMD_DATA_SIZE] = {0};
     uint16_t reqlen = 0;
     uint8_t arg1 = 1;
     int blocknum;
@@ -1085,7 +1085,7 @@ static int CmdHF15Write(const char *Cmd) {
 
     PacketResponseNG resp;
     uint8_t *recv;
-    uint8_t req[USB_CMD_DATA_SIZE] = {0};
+    uint8_t req[PM3_CMD_DATA_SIZE] = {0};
     uint16_t reqlen = 0;
     uint8_t arg1 = 1;
     int pagenum, temp;
diff --git a/client/cmdhfepa.c b/client/cmdhfepa.c
index 6adb71a28..3b6549cce 100644
--- a/client/cmdhfepa.c
+++ b/client/cmdhfepa.c
@@ -108,7 +108,7 @@ static int CmdHFEPAPACEReplay(const char *Cmd) {
     }
 
     // transfer the APDUs to the Proxmark
-    uint8_t data[USB_CMD_DATA_SIZE];
+    uint8_t data[PM3_CMD_DATA_SIZE];
     for (int i = 0; i < sizeof(apdu_lengths); i++) {
         // transfer the APDU in several parts if necessary
         for (int j = 0; j * sizeof(data) < apdu_lengths[i]; j++) {
diff --git a/client/cmdhffelica.c b/client/cmdhffelica.c
index 68c0cfb5b..c61e386c8 100644
--- a/client/cmdhffelica.c
+++ b/client/cmdhffelica.c
@@ -429,7 +429,7 @@ static int CmdHFFelicaCmdRaw(const char *Cmd) {
     uint16_t numbits = 0;
     char buf[5] = "";
     int i = 0;
-    uint8_t data[USB_CMD_DATA_SIZE];
+    uint8_t data[PM3_CMD_DATA_SIZE];
     uint16_t datalen = 0;
     uint32_t temp;
 
@@ -518,8 +518,8 @@ static int CmdHFFelicaCmdRaw(const char *Cmd) {
         flags |= FELICA_RAW;
     }
 
-    // Max buffer is USB_CMD_DATA_SIZE
-    datalen = (datalen > USB_CMD_DATA_SIZE) ? USB_CMD_DATA_SIZE : datalen;
+    // Max buffer is PM3_CMD_DATA_SIZE
+    datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen;
 
     clearCommandBuffer();
     SendCommandOLD(CMD_FELICA_COMMAND, flags, (datalen & 0xFFFF) | (uint32_t)(numbits << 16), 0, data, datalen);
diff --git a/client/cmdhficlass.c b/client/cmdhficlass.c
index 8326834a0..1b0eebff9 100644
--- a/client/cmdhficlass.c
+++ b/client/cmdhficlass.c
@@ -595,7 +595,7 @@ static int CmdHFiClassELoad(const char *Cmd) {
     uint32_t bytes_remaining  = bytes_read;
 
     while (bytes_remaining > 0) {
-        uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
+        uint32_t bytes_in_packet = MIN(PM3_CMD_DATA_SIZE, bytes_remaining);
         clearCommandBuffer();
         SendCommandOLD(CMD_ICLASS_EML_MEMSET, bytes_sent, bytes_in_packet, 0, dump + bytes_sent, bytes_in_packet);
         bytes_remaining -= bytes_in_packet;
@@ -1272,10 +1272,10 @@ static int CmdHFiClassCloneTag(const char *Cmd) {
 
     FILE *f;
 
-    iclass_block_t tag_data[USB_CMD_DATA_SIZE / 12];
+    iclass_block_t tag_data[PM3_CMD_DATA_SIZE / 12];
 
-    if ((endblock - startblock + 1) * 12 > USB_CMD_DATA_SIZE) {
-        PrintAndLogEx(NORMAL, "Trying to write too many blocks at once.  Max: %d", USB_CMD_DATA_SIZE / 8);
+    if ((endblock - startblock + 1) * 12 > PM3_CMD_DATA_SIZE) {
+        PrintAndLogEx(NORMAL, "Trying to write too many blocks at once.  Max: %d", PM3_CMD_DATA_SIZE / 8);
     }
     // file handling and reading
     f = fopen(filename, "rb");
@@ -1944,7 +1944,7 @@ static int CmdHFiClassCheckKeys(const char *Cmd) {
     //PrintPreCalcMac(keyBlock, keycnt, pre);
 
     // max 42 keys inside USB_COMMAND.  512/4 = 103 mac
-    uint32_t chunksize = keycnt > (USB_CMD_DATA_SIZE / 4) ? (USB_CMD_DATA_SIZE / 4) : keycnt;
+    uint32_t chunksize = keycnt > (PM3_CMD_DATA_SIZE / 4) ? (PM3_CMD_DATA_SIZE / 4) : keycnt;
     bool lastChunk = false;
 
     // fast push mode
diff --git a/client/cmdhficlass.h b/client/cmdhficlass.h
index 0ae5a97cd..aa29fae1e 100644
--- a/client/cmdhficlass.h
+++ b/client/cmdhficlass.h
@@ -29,7 +29,7 @@
 #include "loclass/elite_crack.h"
 #include "loclass/fileutils.h"
 #include "protocols.h"
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "cmdhfmfu.h"
 #include "cmdhf.h"
 #include "protocols.h" // picopass structs,
diff --git a/client/cmdhflegic.c b/client/cmdhflegic.c
index ca5f53a2b..85a3a18bc 100644
--- a/client/cmdhflegic.c
+++ b/client/cmdhflegic.c
@@ -833,9 +833,9 @@ void legic_chk_iv(uint32_t *iv) {
 }
 void legic_seteml(uint8_t *src, uint32_t offset, uint32_t numofbytes) {
 
-    for (size_t i = offset; i < numofbytes; i += USB_CMD_DATA_SIZE) {
+    for (size_t i = offset; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
 
-        size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
+        size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
         clearCommandBuffer();
         SendCommandOLD(CMD_LEGIC_ESET, i, len, 0, src + i, len);
     }
@@ -1041,9 +1041,9 @@ static int CmdLegicRestore(const char *Cmd) {
 
     // transfer to device
     PacketResponseNG resp;
-    for (size_t i = 7; i < numofbytes; i += USB_CMD_DATA_SIZE) {
+    for (size_t i = 7; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
 
-        size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
+        size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
         clearCommandBuffer();
         SendCommandOLD(CMD_WRITER_LEGIC_RF, i, len, 0x55, data + i, len);
 
@@ -1230,11 +1230,11 @@ static int CmdLegicWipe(const char *Cmd) {
 
     // transfer to device
     PacketResponseNG resp;
-    for (size_t i = 7; i < card.cardsize; i += USB_CMD_DATA_SIZE) {
+    for (size_t i = 7; i < card.cardsize; i += PM3_CMD_DATA_SIZE) {
 
         printf(".");
         fflush(stdout);
-        size_t len = MIN((card.cardsize - i), USB_CMD_DATA_SIZE);
+        size_t len = MIN((card.cardsize - i), PM3_CMD_DATA_SIZE);
         clearCommandBuffer();
         SendCommandOLD(CMD_WRITER_LEGIC_RF, i, len, 0x55, data + i, len);
 
diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index 03e2689a5..f45222773 100644
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -1661,7 +1661,7 @@ static int CmdHF14AMfChk_fast(const char *Cmd) {
         return 1;
     }
 
-    uint32_t chunksize = keycnt > (USB_CMD_DATA_SIZE / 6) ? (USB_CMD_DATA_SIZE / 6) : keycnt;
+    uint32_t chunksize = keycnt > (PM3_CMD_DATA_SIZE / 6) ? (PM3_CMD_DATA_SIZE / 6) : keycnt;
     bool firstChunk = true, lastChunk = false;
 
     // time
@@ -1933,7 +1933,7 @@ static int CmdHF14AMfChk(const char *Cmd) {
 
 
     uint8_t trgKeyType = 0;
-    uint32_t max_keys = keycnt > ((USB_CMD_DATA_SIZE - 4) / 6) ? ((USB_CMD_DATA_SIZE - 4) / 6) : keycnt;
+    uint32_t max_keys = keycnt > ((PM3_CMD_DATA_SIZE - 4) / 6) ? ((PM3_CMD_DATA_SIZE - 4) / 6) : keycnt;
 
     // time
     uint64_t t1 = msclock();
diff --git a/client/cmdhw.c b/client/cmdhw.c
index 461e48f0b..2a62d3e67 100644
--- a/client/cmdhw.c
+++ b/client/cmdhw.c
@@ -442,12 +442,12 @@ static int CmdPing(const char *Cmd) {
 
 static int CmdPingNG(const char *Cmd) {
     uint32_t len = strtol(Cmd, NULL, 0);
-    if (len > USB_CMD_DATA_SIZE)
-        len = USB_CMD_DATA_SIZE;
+    if (len > PM3_CMD_DATA_SIZE)
+        len = PM3_CMD_DATA_SIZE;
     PrintAndLogEx(NORMAL, "PingNG sent with payload len=%d", len);
     clearCommandBuffer();
     PacketResponseNG resp;
-    uint8_t data[USB_CMD_DATA_SIZE] = {0};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0};
     for (uint16_t i = 0; i < len; i++)
         data[i] = i & 0xFF;
     SendCommandNG(CMD_PING, data, len);
diff --git a/client/cmdlf.c b/client/cmdlf.c
index 71209d554..1e5878cf2 100644
--- a/client/cmdlf.c
+++ b/client/cmdlf.c
@@ -149,7 +149,7 @@ int CmdLFCommandRead(const char *Cmd) {
     uint32_t arg0 = 0;
     uint32_t arg1 = 0;
     uint32_t arg2 = 0;
-    uint8_t data[USB_CMD_DATA_SIZE];
+    uint8_t data[PM3_CMD_DATA_SIZE];
     uint16_t datalen = 0;
 
     uint8_t cmdp = 0;
@@ -423,9 +423,9 @@ int CmdLFSim(const char *Cmd) {
     conn.block_after_ACK = true;
     
     //can send only 512 bits at a time (1 byte sent per bit...)
-    for (uint16_t i = 0; i < GraphTraceLen; i += USB_CMD_DATA_SIZE) {
+    for (uint16_t i = 0; i < GraphTraceLen; i += PM3_CMD_DATA_SIZE) {
         clearCommandBuffer();
-        SendCommandOLD(CMD_UPLOAD_SIM_SAMPLES_125K, i, FPGA_LF, 0, &GraphBuffer[i], USB_CMD_DATA_SIZE);
+        SendCommandOLD(CMD_UPLOAD_SIM_SAMPLES_125K, i, FPGA_LF, 0, &GraphBuffer[i], PM3_CMD_DATA_SIZE);
         WaitForResponse(CMD_ACK, NULL);
         printf(".");
         fflush(stdout);
@@ -518,9 +518,9 @@ int CmdLFfskSim(const char *Cmd) {
     if (fcLow == 0) fcLow = 8;
 
     size_t size = DemodBufferLen;
-    if (size > USB_CMD_DATA_SIZE) {
-        PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
-        size = USB_CMD_DATA_SIZE;
+    if (size > PM3_CMD_DATA_SIZE) {
+        PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, PM3_CMD_DATA_SIZE);
+        size = PM3_CMD_DATA_SIZE;
     }
     clearCommandBuffer();
     SendCommandOLD(CMD_FSK_SIM_TAG, fcHigh << 8 | fcLow, (separator << 8) | clk, size, DemodBuffer, size);
@@ -603,9 +603,9 @@ int CmdLFaskSim(const char *Cmd) {
     if (encoding == 0) clk /= 2; //askraw needs to double the clock speed
 
     size_t size = DemodBufferLen;
-    if (size > USB_CMD_DATA_SIZE) {
-        PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
-        size = USB_CMD_DATA_SIZE;
+    if (size > PM3_CMD_DATA_SIZE) {
+        PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, PM3_CMD_DATA_SIZE);
+        size = PM3_CMD_DATA_SIZE;
     }
 
     PrintAndLogEx(NORMAL, "preparing to sim ask data: %d bits", size);
@@ -707,9 +707,9 @@ int CmdLFpskSim(const char *Cmd) {
         }
     }
     size_t size = DemodBufferLen;
-    if (size > USB_CMD_DATA_SIZE) {
-        PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
-        size = USB_CMD_DATA_SIZE;
+    if (size > PM3_CMD_DATA_SIZE) {
+        PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, PM3_CMD_DATA_SIZE);
+        size = PM3_CMD_DATA_SIZE;
     }
     PrintAndLogEx(DEBUG, "DEBUG: Sending DemodBuffer Length: %d", size);
     clearCommandBuffer();
diff --git a/client/cmdlfhitag.c b/client/cmdlfhitag.c
index 3d4138565..a7e2aee26 100644
--- a/client/cmdlfhitag.c
+++ b/client/cmdlfhitag.c
@@ -128,7 +128,7 @@ static int CmdLFHitagList(const char *Cmd) {
     return 0;
 
     /*
-    uint8_t *got = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
+    uint8_t *got = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
     if (!got) {
         PrintAndLogEx(WARNING, "Cannot allocate memory for trace");
         return 2;
@@ -136,14 +136,14 @@ static int CmdLFHitagList(const char *Cmd) {
 
     // Query for the actual size of the trace
     PacketResponseNG response;
-    if (!GetFromDevice(BIG_BUF, got, USB_CMD_DATA_SIZE, 0, &response, 2500, false)) {
+    if (!GetFromDevice(BIG_BUF, got, PM3_CMD_DATA_SIZE, 0, &response, 2500, false)) {
         PrintAndLogEx(WARNING, "command execution time out");
         free(got);
         return 2;
     }
 
     uint16_t traceLen = response.arg[2];
-    if (traceLen > USB_CMD_DATA_SIZE) {
+    if (traceLen > PM3_CMD_DATA_SIZE) {
         uint8_t *p = realloc(got, traceLen);
         if (p == NULL) {
             PrintAndLogEx(WARNING, "Cannot allocate memory for trace");
diff --git a/client/cmdmain.h b/client/cmdmain.h
index 8a43ad6b8..0bf5ff1e7 100644
--- a/client/cmdmain.h
+++ b/client/cmdmain.h
@@ -19,7 +19,7 @@
 #include <string.h>
 #include "util_posix.h"
 #include "proxmark3.h"
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "util.h"
 #include "ui.h"
 #include "cmdparser.h"
diff --git a/client/cmdsmartcard.c b/client/cmdsmartcard.c
index 3f9703ccd..b5b303534 100644
--- a/client/cmdsmartcard.c
+++ b/client/cmdsmartcard.c
@@ -395,7 +395,7 @@ static int CmdSmartRaw(const char *Cmd) {
     bool useT0 = false;
     uint8_t cmdp = 0;
     bool errors = false, reply = true, decodeTLV = false, breakloop = false;
-    uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
 
     while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
         switch (tolower(param_getchar(Cmd, cmdp))) {
@@ -470,7 +470,7 @@ static int CmdSmartRaw(const char *Cmd) {
     // reading response from smart card
     if (reply) {
 
-        uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
+        uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
         if (!buf)
             return 1;
 
@@ -644,7 +644,7 @@ static int CmdSmartUpgrade(const char *Cmd) {
     uint32_t bytes_remaining = firmware_size;
 
     while (bytes_remaining > 0) {
-        uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
+        uint32_t bytes_in_packet = MIN(PM3_CMD_DATA_SIZE, bytes_remaining);
         clearCommandBuffer();
         SendCommandOLD(CMD_SMART_UPLOAD, index + bytes_sent, bytes_in_packet, 0, dump + bytes_sent, bytes_in_packet);
         if (!WaitForResponseTimeout(CMD_ACK, NULL, 2000)) {
@@ -858,7 +858,7 @@ static int CmdSmartList(const char *Cmd) {
 
 static void smart_brute_prim() {
 
-    uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
+    uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
     if (!buf)
         return;
 
@@ -891,7 +891,7 @@ static void smart_brute_prim() {
 
 static int smart_brute_sfi(bool decodeTLV) {
 
-    uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
+    uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
     if (!buf)
         return 1;
 
@@ -945,7 +945,7 @@ static int smart_brute_sfi(bool decodeTLV) {
                     }
                 }
             }
-            memset(buf, 0x00, USB_CMD_DATA_SIZE);
+            memset(buf, 0x00, PM3_CMD_DATA_SIZE);
         }
     }
     free(buf);
@@ -954,7 +954,7 @@ static int smart_brute_sfi(bool decodeTLV) {
 
 static void smart_brute_options(bool decodeTLV) {
 
-    uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
+    uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
     if (!buf)
         return;
 
@@ -1019,7 +1019,7 @@ static int CmdSmartBruteforceSFI(const char *Cmd) {
     json_t *root = NULL;
     smart_loadjson("aidlist", "json", &root);
 
-    uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
+    uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
     if (!buf)
         return 1;
 
@@ -1064,7 +1064,7 @@ static int CmdSmartBruteforceSFI(const char *Cmd) {
         snprintf(caid, 8 + 2 + aidlen + 1, SELECT, aidlen >> 1, aid);
 
         int hexlen = 0;
-        uint8_t cmddata[USB_CMD_DATA_SIZE];
+        uint8_t cmddata[PM3_CMD_DATA_SIZE];
         int res = param_gethex_to_eol(caid, 0, cmddata, sizeof(cmddata), &hexlen);
         if (res)
             continue;
diff --git a/client/cmdtrace.c b/client/cmdtrace.c
index f243999a5..a329f8931 100644
--- a/client/cmdtrace.c
+++ b/client/cmdtrace.c
@@ -664,18 +664,18 @@ int CmdTraceList(const char *Cmd) {
 
     // reserv some space.
     if (!trace)
-        trace = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
+        trace = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
 
     if (isOnline) {
-        // Query for the size of the trace,  downloading USB_CMD_DATA_SIZE
+        // Query for the size of the trace,  downloading PM3_CMD_DATA_SIZE
         PacketResponseNG response;
-        if (!GetFromDevice(BIG_BUF, trace, USB_CMD_DATA_SIZE, 0, &response, 4000, true)) {
+        if (!GetFromDevice(BIG_BUF, trace, PM3_CMD_DATA_SIZE, 0, &response, 4000, true)) {
             PrintAndLogEx(WARNING, "timeout while waiting for reply.");
             return 1;
         }
 
         traceLen = response.oldarg[2];
-        if (traceLen > USB_CMD_DATA_SIZE) {
+        if (traceLen > PM3_CMD_DATA_SIZE) {
             uint8_t *p = realloc(trace, traceLen);
             if (p == NULL) {
                 PrintAndLogEx(FAILED, "Cannot allocate memory for trace");
diff --git a/client/comms.c b/client/comms.c
index 869de55c6..5037c1598 100644
--- a/client/comms.c
+++ b/client/comms.c
@@ -123,7 +123,7 @@ static void SendCommandNG_internal(uint16_t cmd, uint8_t *data, size_t len, bool
         PrintAndLogEx(NORMAL, "Sending bytes to proxmark failed - offline");
         return;
     }
-    if (len > USB_CMD_DATA_SIZE) {
+    if (len > PM3_CMD_DATA_SIZE) {
         PrintAndLogEx(WARNING, "Sending %d bytes of payload is too much, abort", len);
         return;
     }
@@ -182,11 +182,11 @@ void SendCommandNG(uint16_t cmd, uint8_t *data, size_t len) {
 
 void SendCommandMIX(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len) {
     uint64_t arg[3] = {arg0, arg1, arg2};
-    if (len > USB_CMD_DATA_SIZE_MIX) {
+    if (len > PM3_CMD_DATA_SIZE_MIX) {
         PrintAndLogEx(WARNING, "Sending %d bytes of payload is too much for MIX frames, abort", len);
         return;
     }
-    uint8_t cmddata[USB_CMD_DATA_SIZE];
+    uint8_t cmddata[PM3_CMD_DATA_SIZE];
     memcpy(cmddata, arg, sizeof(arg));
     if (len && data)
         memcpy(cmddata + sizeof(arg), data, len);
@@ -307,7 +307,7 @@ static void PacketResponseReceived(PacketResponseNG *packet) {
         // First check if we are handling a debug message
         case CMD_DEBUG_PRINT_STRING: {
 
-            char s[USB_CMD_DATA_SIZE + 1];
+            char s[PM3_CMD_DATA_SIZE + 1];
             memset(s, 0x00, sizeof(s));
 
             size_t len;
@@ -315,14 +315,14 @@ static void PacketResponseReceived(PacketResponseNG *packet) {
             if (packet->ng) {
                 struct d {
                     uint16_t flag;
-                    uint8_t buf[USB_CMD_DATA_SIZE - sizeof(uint16_t)];
+                    uint8_t buf[PM3_CMD_DATA_SIZE - sizeof(uint16_t)];
                 } PACKED;
                 struct d *data = (struct d *)&packet->data.asBytes;
                 len = packet->length - sizeof(data->flag);
                 flag = data->flag;
                 memcpy_filtered(s, data->buf, len, flag & FLAG_ANSI);
             } else {
-                len = MIN(packet->oldarg[0], USB_CMD_DATA_SIZE);
+                len = MIN(packet->oldarg[0], PM3_CMD_DATA_SIZE);
                 flag = packet->oldarg[1];
                 memcpy_filtered(s, packet->data.asBytes, len, flag & FLAG_ANSI);
             }
@@ -410,7 +410,7 @@ __attribute__((force_align_arg_pointer))
             rx.status = rx_raw.pre.status;
             rx.cmd = rx_raw.pre.cmd;
             if (rx.magic == RESPONSENG_PREAMBLE_MAGIC) { // New style NG reply
-                if (length > USB_CMD_DATA_SIZE) {
+                if (length > PM3_CMD_DATA_SIZE) {
                     PrintAndLogEx(WARNING, "Received packet frame with incompatible length: 0x%04x", length);
                     error = true;
                 }
@@ -496,7 +496,7 @@ __attribute__((force_align_arg_pointer))
                     rx.oldarg[0] = rx_old.arg[0];
                     rx.oldarg[1] = rx_old.arg[1];
                     rx.oldarg[2] = rx_old.arg[2];
-                    rx.length = USB_CMD_DATA_SIZE;
+                    rx.length = PM3_CMD_DATA_SIZE;
                     memcpy(&rx.data, &rx_old.d, rx.length);
                     PacketResponseReceived(&rx);
                     if (rx.cmd == CMD_ACK) {
@@ -829,9 +829,9 @@ static bool dl_it(uint8_t *dest, uint32_t bytes, uint32_t start_index, PacketRes
                 uint32_t copy_bytes = MIN(bytes - bytes_completed, response->oldarg[1]);
                 //uint32_t tracelen = response->oldarg[2];
 
-                // extended bounds check1.  upper limit is USB_CMD_DATA_SIZE
+                // extended bounds check1.  upper limit is PM3_CMD_DATA_SIZE
                 // shouldn't happen
-                copy_bytes = MIN(copy_bytes, USB_CMD_DATA_SIZE);
+                copy_bytes = MIN(copy_bytes, PM3_CMD_DATA_SIZE);
 
                 // extended bounds check2.
                 if (offset + copy_bytes > bytes) {
diff --git a/client/comms.h b/client/comms.h
index 516d39b1a..c53b75bee 100644
--- a/client/comms.h
+++ b/client/comms.h
@@ -15,7 +15,7 @@
 #include <stdbool.h>
 #include <pthread.h>
 
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "uart.h"
 #include "ui.h"
 #include "common.h"
diff --git a/client/flash.h b/client/flash.h
index b474c79b6..a230715d1 100644
--- a/client/flash.h
+++ b/client/flash.h
@@ -18,7 +18,7 @@
 #include "proxmark3.h"
 #include "elf.h"
 #include "proxendian.h"
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "at91sam7s512.h"
 #include "util_posix.h"
 #include "util.h"
diff --git a/client/flasher.c b/client/flasher.c
index 817990d7e..fe96b9681 100644
--- a/client/flasher.c
+++ b/client/flasher.c
@@ -16,7 +16,7 @@
 #include "util.h"
 #include "flash.h"
 #include "comms.h"
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 
 #define MAX_FILES 4
 
diff --git a/client/mifare/mifarehost.c b/client/mifare/mifarehost.c
index 293fc76b0..5c0d31771 100644
--- a/client/mifare/mifarehost.c
+++ b/client/mifare/mifarehost.c
@@ -89,8 +89,8 @@ int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key) {
         PrintAndLogEx(SUCCESS, "found %u candidate key%s\n", keycount, (keycount > 1) ? "s." : ".");
 
         *key = UINT64_C(-1);
-        uint8_t keyBlock[USB_CMD_DATA_SIZE];
-        uint32_t max_keys = (USB_CMD_DATA_SIZE - 4) / 6;
+        uint8_t keyBlock[PM3_CMD_DATA_SIZE];
+        uint32_t max_keys = (PM3_CMD_DATA_SIZE - 4) / 6;
         for (uint32_t i = 0; i < keycount; i += max_keys) {
 
             uint32_t size = keycount - i > max_keys ? max_keys : keycount - i;
@@ -123,7 +123,7 @@ int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key) {
 int mfCheckKeys(uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t *keyBlock, uint64_t *key) {
     *key = -1;
     clearCommandBuffer();   
-    uint8_t data[USB_CMD_DATA_SIZE] = {0};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0};
     data[0] = keyType;
     data[1] = blockNo;
     data[2] = clear_trace;
@@ -220,7 +220,7 @@ int mfCheckKeys_fast(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk,
 // ref: https://github.com/J-Run/mf_key_brute
 int mfKeyBrute(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint64_t *resultkey) {
 
-#define KEYS_IN_BLOCK   ((USB_CMD_DATA_SIZE - 4) / 6)
+#define KEYS_IN_BLOCK   ((PM3_CMD_DATA_SIZE - 4) / 6)
 #define KEYBLOCK_SIZE   (KEYS_IN_BLOCK * 6)
 #define CANDIDATE_SIZE  (0xFFFF * 6)
 
@@ -379,8 +379,8 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo,
     uint64_t key64 = -1;
 
     // The list may still contain several key candidates. Test each of them with mfCheckKeys
-    uint32_t max_keys = keycnt > ((USB_CMD_DATA_SIZE - 4) / 6) ? ((USB_CMD_DATA_SIZE - 4) / 6) : keycnt;
-    uint8_t keyBlock[USB_CMD_DATA_SIZE] = {0x00};
+    uint32_t max_keys = keycnt > ((PM3_CMD_DATA_SIZE - 4) / 6) ? ((PM3_CMD_DATA_SIZE - 4) / 6) : keycnt;
+    uint8_t keyBlock[PM3_CMD_DATA_SIZE] = {0x00};
 
     for (i = 0; i < keycnt; i += max_keys) {
 
diff --git a/client/usb_cmd_h2lua.awk b/client/pm3_cmd_h2lua.awk
similarity index 85%
rename from client/usb_cmd_h2lua.awk
rename to client/pm3_cmd_h2lua.awk
index e18bea523..a7b3409dd 100644
--- a/client/usb_cmd_h2lua.awk
+++ b/client/pm3_cmd_h2lua.awk
@@ -1,7 +1,7 @@
 BEGIN {
     print "--[["
     print "These are Proxmark command definitions."
-    print "This file is automatically generated from usb_cmd.h - DON'T EDIT MANUALLY."
+    print "This file is automatically generated from pm3_cmd.h - DON'T EDIT MANUALLY."
     print "--]]"
     print "local __commands = {"
 }
diff --git a/client/proxmark3.h b/client/proxmark3.h
index 5d5a49c9a..20664ab81 100644
--- a/client/proxmark3.h
+++ b/client/proxmark3.h
@@ -12,7 +12,7 @@
 #ifndef PROXMARK3_H__
 #define PROXMARK3_H__
 
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "cmdscript.h"  // CmdScriptRun
 
 #define PROXPROMPT "pm3 --> "
diff --git a/client/scripting.c b/client/scripting.c
index 70943f360..e855c0fe9 100644
--- a/client/scripting.c
+++ b/client/scripting.c
@@ -90,7 +90,7 @@ static int l_SendCommandOLD(lua_State *L) {
 // (uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len)
 
     uint64_t cmd, arg0, arg1, arg2;
-    uint8_t data[USB_CMD_DATA_SIZE] = {0};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0};
     size_t len = 0, size;
 
     //Check number of arguments
@@ -138,7 +138,7 @@ static int l_SendCommandOLD(lua_State *L) {
 static int l_SendCommandMIX(lua_State *L) {
 
     uint64_t cmd, arg0, arg1, arg2;
-    uint8_t data[USB_CMD_DATA_SIZE] = {0};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0};
     size_t len = 0, size;
 
     // check number of arguments
@@ -180,7 +180,7 @@ static int l_SendCommandMIX(lua_State *L) {
  */
 static int l_SendCommandNG(lua_State *L) {
 
-    uint8_t data[USB_CMD_DATA_SIZE] = {0};
+    uint8_t data[PM3_CMD_DATA_SIZE] = {0};
     size_t len = 0, size;
 
     // check number of arguments
@@ -414,7 +414,7 @@ static int l_CmdConsole(lua_State *L) {
 
 static int l_iso15693_crc(lua_State *L) {
     uint32_t tmp;
-    unsigned char buf[USB_CMD_DATA_SIZE] = {0x00};
+    unsigned char buf[PM3_CMD_DATA_SIZE] = {0x00};
     size_t size = 0;
     const char *data = luaL_checklstring(L, 1, &size);
 
@@ -431,7 +431,7 @@ static int l_iso15693_crc(lua_State *L) {
 
 static int l_iso14443b_crc(lua_State *L) {
     uint32_t tmp;
-    unsigned char buf[USB_CMD_DATA_SIZE] = {0x00};
+    unsigned char buf[PM3_CMD_DATA_SIZE] = {0x00};
     size_t size = 0;
     const char *data = luaL_checklstring(L, 1, &size);
 
diff --git a/client/scripting.h b/client/scripting.h
index 4db566dcc..5b8c15ddd 100644
--- a/client/scripting.h
+++ b/client/scripting.h
@@ -15,7 +15,7 @@
 #include <lualib.h>
 #include <lauxlib.h>
 #include "proxmark3.h"
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "cmdmain.h"
 #include "comms.h"
 #include "util.h"
diff --git a/common/Makefile.common b/common/Makefile.common
index bfbfc0a80..a0e44fbe9 100644
--- a/common/Makefile.common
+++ b/common/Makefile.common
@@ -62,7 +62,7 @@ endif
 # Also search prerequisites in the common directory (for usb.c), the fpga directory (for fpga.bit), and the zlib directory
 VPATH = . ../common ../common/crapto1 ../common/polarssl ../fpga ../zlib ../armsrc/Standalone ../uart
 
-INCLUDES = ../include/proxmark3.h ../include/at91sam7s512.h ../include/config_gpio.h ../include/usb_cmd.h $(APP_INCLUDES)
+INCLUDES = ../include/proxmark3.h ../include/at91sam7s512.h ../include/config_gpio.h ../include/pm3_cmd.h $(APP_INCLUDES)
 
 CFLAGS =  -c $(INCLUDE) -Wall -Werror -pedantic -Wunused -std=c99 $(APP_CFLAGS) -Os
 LDFLAGS = -nostartfiles -nodefaultlibs -Wl,-gc-sections -n
diff --git a/common/cmd.c b/common/cmd.c
index 2605c40e8..caf85748e 100644
--- a/common/cmd.c
+++ b/common/cmd.c
@@ -59,9 +59,9 @@ int reply_old(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *d
     txcmd.arg[1] = arg1;
     txcmd.arg[2] = arg2;
 
-    // Add the (optional) content to the frame, with a maximum size of USB_CMD_DATA_SIZE
+    // Add the (optional) content to the frame, with a maximum size of PM3_CMD_DATA_SIZE
     if (data && len) {
-        len = MIN(len, USB_CMD_DATA_SIZE);
+        len = MIN(len, PM3_CMD_DATA_SIZE);
         for (size_t i = 0; i < len; i++) {
             txcmd.d.asBytes[i] = ((uint8_t *)data)[i];
         }
@@ -95,14 +95,14 @@ static int reply_ng_internal(uint16_t cmd, int16_t status, uint8_t *data, size_t
     txBufferNG.pre.cmd = cmd;
     txBufferNG.pre.status = status;
     txBufferNG.pre.ng = ng;
-    if (len > USB_CMD_DATA_SIZE) {
-        len = USB_CMD_DATA_SIZE;
+    if (len > PM3_CMD_DATA_SIZE) {
+        len = PM3_CMD_DATA_SIZE;
         // overwrite status
         txBufferNG.pre.status = PM3_EOVFLOW;
     }
     txBufferNG.pre.length = len;
 
-    // Add the (optional) content to the frame, with a maximum size of USB_CMD_DATA_SIZE
+    // Add the (optional) content to the frame, with a maximum size of PM3_CMD_DATA_SIZE
     if (data && len) {
         for (size_t i = 0; i < len; i++) {
             txBufferNG.data[i] = data[i];
@@ -143,11 +143,11 @@ int reply_ng(uint16_t cmd, int16_t status, uint8_t *data, size_t len) {
 int reply_mix(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len) {
     uint16_t status = PM3_SUCCESS;
     uint64_t arg[3] = {arg0, arg1, arg2};
-    if (len > USB_CMD_DATA_SIZE - sizeof(arg)) {
-        len = USB_CMD_DATA_SIZE - sizeof(arg);
+    if (len > PM3_CMD_DATA_SIZE - sizeof(arg)) {
+        len = PM3_CMD_DATA_SIZE - sizeof(arg);
         status = PM3_EOVFLOW;
     }
-    uint8_t cmddata[USB_CMD_DATA_SIZE];
+    uint8_t cmddata[PM3_CMD_DATA_SIZE];
     memcpy(cmddata, arg, sizeof(arg));
     if (len && data)
         memcpy(cmddata + sizeof(arg), data, len);
@@ -166,7 +166,7 @@ static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *da
     uint16_t length = rx_raw.pre.length;
     rx->cmd = rx_raw.pre.cmd;
     if (rx->magic == COMMANDNG_PREAMBLE_MAGIC) { // New style NG command
-        if (length > USB_CMD_DATA_SIZE)
+        if (length > PM3_CMD_DATA_SIZE)
             return PM3_EOVFLOW;
         // Get the core and variable length payload
         bytes = read_ng((uint8_t *)&rx_raw.data, length);
@@ -213,7 +213,7 @@ static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *da
         rx->oldarg[0] = rx_old.arg[0];
         rx->oldarg[1] = rx_old.arg[1];
         rx->oldarg[2] = rx_old.arg[2];
-        rx->length = USB_CMD_DATA_SIZE;
+        rx->length = PM3_CMD_DATA_SIZE;
         memcpy(&rx->data, &rx_old.d.asBytes, rx->length);
     }
     return PM3_SUCCESS;
diff --git a/common/cmd.h b/common/cmd.h
index fd42607f9..352da88d4 100644
--- a/common/cmd.h
+++ b/common/cmd.h
@@ -34,7 +34,7 @@
 #define _PROXMARK_CMD_H_
 
 #include "common.h"
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 #include "usb_cdc.h"
 #include "usart.h"
 #include "proxmark3.h"
diff --git a/include/usb_cmd.h b/include/pm3_cmd.h
similarity index 97%
rename from include/usb_cmd.h
rename to include/pm3_cmd.h
index 4d4a9e8dd..41ebf221c 100644
--- a/include/usb_cmd.h
+++ b/include/pm3_cmd.h
@@ -27,15 +27,15 @@ typedef BYTE uint8_t;
 #define PACKED __attribute__((packed))
 #endif
 
-#define USB_CMD_DATA_SIZE 512
-#define USB_CMD_DATA_SIZE_MIX ( USB_CMD_DATA_SIZE - 3 * sizeof(uint64_t) )
+#define PM3_CMD_DATA_SIZE 512
+#define PM3_CMD_DATA_SIZE_MIX ( PM3_CMD_DATA_SIZE - 3 * sizeof(uint64_t) )
 
 typedef struct {
     uint64_t cmd;
     uint64_t arg[3];
     union {
-        uint8_t  asBytes[USB_CMD_DATA_SIZE];
-        uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
+        uint8_t  asBytes[PM3_CMD_DATA_SIZE];
+        uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
     } d;
 } PACKED PacketCommandOLD;
 
@@ -61,8 +61,8 @@ typedef struct {
     uint16_t crc;        //  NG
     uint64_t oldarg[3];  //  OLD
     union {
-        uint8_t  asBytes[USB_CMD_DATA_SIZE];
-        uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
+        uint8_t  asBytes[PM3_CMD_DATA_SIZE];
+        uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
     } data;
     bool ng;             // does it store NG data or OLD data?
 } PACKED PacketCommandNG;
@@ -70,7 +70,7 @@ typedef struct {
 // For reception and CRC check
 typedef struct {
     PacketCommandNGPreamble pre;
-    uint8_t data[USB_CMD_DATA_SIZE];
+    uint8_t data[PM3_CMD_DATA_SIZE];
     PacketCommandNGPostamble foopost; // Probably not at that offset!
 } PACKED PacketCommandNGRaw;
 
@@ -78,8 +78,8 @@ typedef struct {
     uint64_t cmd;
     uint64_t arg[3];
     union {
-        uint8_t  asBytes[USB_CMD_DATA_SIZE];
-        uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
+        uint8_t  asBytes[PM3_CMD_DATA_SIZE];
+        uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
     } d;
 } PACKED PacketResponseOLD;
 
@@ -107,8 +107,8 @@ typedef struct {
     uint16_t crc;        //  NG
     uint64_t oldarg[3];  //  OLD
     union {
-        uint8_t  asBytes[USB_CMD_DATA_SIZE];
-        uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
+        uint8_t  asBytes[PM3_CMD_DATA_SIZE];
+        uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
     } data;
     bool ng;             // does it store NG data or OLD data?
 } PACKED PacketResponseNG;
@@ -116,7 +116,7 @@ typedef struct {
 // For reception and CRC check
 typedef struct {
     PacketResponseNGPreamble pre;
-    uint8_t data[USB_CMD_DATA_SIZE];
+    uint8_t data[PM3_CMD_DATA_SIZE];
     PacketResponseNGPostamble foopost; // Probably not at that offset!
 } PACKED PacketResponseNGRaw;
 
diff --git a/include/proxmark3.h b/include/proxmark3.h
index 0dc4aea94..3cdf3147e 100644
--- a/include/proxmark3.h
+++ b/include/proxmark3.h
@@ -14,7 +14,7 @@
 // Might as well have the hardware-specific defines everywhere.
 #include "at91sam7s512.h"
 #include "config_gpio.h"
-#include "usb_cmd.h"
+#include "pm3_cmd.h"
 
 #define WDT_HIT()                               AT91C_BASE_WDTC->WDTC_WDCR = 0xa5000001
 
diff --git a/uart/uart_posix.c b/uart/uart_posix.c
index a39fb7d89..aeac79b43 100644
--- a/uart/uart_posix.c
+++ b/uart/uart_posix.c
@@ -67,7 +67,7 @@ typedef struct {
     term_info tiNew;  // Terminal info during the transaction
 } serial_port_unix;
 
-// see usb_cmd.h
+// see pm3_cmd.h
 struct timeval timeout = {
     .tv_sec  = 0, // 0 second
     .tv_usec = UART_FPC_CLIENT_RX_TIMEOUT_MS * 1000