--- /dev/null
+#COMMON_FLAGS = -m32
+LDLIBS = -L/usr/local/lib -lusb -lreadline -lpthread
+LDFLAGS = $(COMMON_FLAGS)
+CFLAGS = -I. -I/opt/local/include -Wall -Wno-unused-function $(COMMON_FLAGS)
+
+CXXFLAGS = $(shell pkg-config --cflags QtCore QtGui 2>/dev/null) -Wall
+QTLDLIBS = $(shell pkg-config --libs QtCore QtGui 2>/dev/null)
+
+ifneq ($(QTLDLIBS),)
+QTGUI = proxgui.o proxguiqt.o proxguiqt.moc.o
+CFLAGS += -DHAVE_GUI
+MOC = $(shell type moc-qt4 >/dev/null 2>&1 && echo moc-qt4 || echo moc)
+LINK.o = $(LINK.cpp)
+else
+QTGUI = guidummy.o
+endif
+
+all: proxmark3 snooper cli flasher
+
+all-static: LDLIBS:=-static $(LDLIBS)
+all-static: snooper cli flasher
+
+proxmark3: LDLIBS+=$(QTLDLIBS)
+proxmark3: proxmark3.o gui.o command.o usb.o $(QTGUI)
+
+command.o: command.cpp translate.h
+
+snooper: snooper.o gui.o command.o usb.o guidummy.o
+
+cli: cli.o gui.o command.o usb.o guidummy.o
+
+flasher: flasher.o usb.o
+
+proxguiqt.moc.cpp: proxguiqt.h
+ $(MOC) -o$@ $^
+
+clean:
+ rm -f cli flasher proxmark3 snooper *.o *.moc.cpp
+
+.PHONY: all clean
--- /dev/null
+CC=cl\r
+BASE_DIR ?= "..\..\devkitWIN"\r
+BASE_DEFS = /D_WIN32_WINNT=0x501 /DISOLATION_AWARE_ENABLED /D_WIN32_IE=0x600 /DWIN32_LEAN_AND_MEAN /DWIN32 /D_MT /D_CRT_SECURE_NO_WARNINGS\r
+BASE_CFLAGS = /W3 /nologo /Zi /MT /Fdobj/vc90.pdb\r
+LIB = $(BASE_DIR)\lib\r
+\r
+DEFINES = $(BASE_DEFS)\r
+INCLUDES = /I$(BASE_DIR)\include\r
+CFLAGS = $(BASE_CFLAGS) $(INCLUDES)\r
+\r
+OBJDIR = obj\r
+\r
+OBJS = $(OBJDIR)\prox.obj \\r
+ $(OBJDIR)\gui.obj \\r
+ $(OBJDIR)\command.obj\r
+\r
+LIBS = $(LIB)\user32.lib $(LIB)\gdi32.lib $(LIB)\setupapi.lib $(LIB)\libcmt.lib $(LIB)\oldnames.lib $(LIB)\kernel32.lib\r
+\r
+all: proxmark3\r
+\r
+proxmark3:\r
+ $(CC) $(CFLAGS) $(DEFINES) -c -Foobj/prox.obj prox.cpp\r
+ $(CC) $(CFLAGS) $(DEFINES) -c -Foobj/gui.obj gui.cpp\r
+ $(CC) $(CFLAGS) $(DEFINES) -c -Foobj/command.obj command.cpp\r
+ $(CC) $(CFLAGS) $(DEFINES) -Fe$(OBJDIR)/prox.exe $(OBJS) $(LIBS)\r
+ copy obj\prox.exe .\r
+\r
+clean:\r
+ del /q obj\*.obj\r
+ del /q obj\*.ilk\r
+ del /q obj\*.exe\r
+ del /q obj\*.pdb\r
+ del prox.exe
\ No newline at end of file
--- /dev/null
+#include <usb.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <string.h>
+#include <errno.h>
+
+#include "translate.h"
+#include "prox.h"
+#include "proxmark3.h"
+
+#define HANDLE_ERROR if (error_occured) { \
+ error_occured = 0;\
+ break;\
+}
+
+int main(int argc, char **argv)
+{
+ if(argc != 3 && argc != 4)
+ {
+ printf("\n\tusage: cli <command 1> <command 2> [logfile (default cli.log)]\n");
+ printf("\n");
+ printf("\texample: cli hi14asnoop hi14alist h14a.log\n");
+ printf("\n");
+ return -1;
+ }
+
+ usb_init();
+ if (argc == 4)
+ setlogfilename(argv[3]);
+ else
+ setlogfilename("cli.log");
+
+ return_on_error = 1;
+
+ while(1) {
+ while(!(devh=OpenProxmark(0))) { sleep(1); }
+
+ while(1) {
+ UsbCommand cmdbuf;
+ int i;
+
+ CommandReceived(argv[1]);
+ HANDLE_ERROR
+
+ ReceiveCommand(&cmdbuf);
+ HANDLE_ERROR
+ for (i=0; i<5; i++) {
+ ReceiveCommandP(&cmdbuf);
+ }
+ HANDLE_ERROR
+
+ CommandReceived(argv[2]);
+ HANDLE_ERROR
+ }
+ }
+
+ CloseProxmark();
+ return 0;
+}
--- /dev/null
+#include "translate.h"
+#include "command.cpp"
--- /dev/null
+//-----------------------------------------------------------------------------\r
+// The actual command interpeter for what the user types at the command line.\r
+// Jonathan Westhues, Sept 2005\r
+// Edits by Gerhard de Koning Gans, Sep 2007 (##)\r
+//-----------------------------------------------------------------------------\r
+#include <windows.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+#include <stdio.h>\r
+#include <limits.h>\r
+#include <math.h>\r
+\r
+#include "prox.h"\r
+#include "../common/iso14443_crc.c"\r
+#include "../common/crc16.c"\r
+\r
+#define arraylen(x) (sizeof(x)/sizeof((x)[0]))\r
+#define BIT(x) GraphBuffer[x * clock]\r
+#define BITS (GraphTraceLen / clock)\r
+\r
+int go = 0;\r
+static int CmdHisamplest(char *str, int nrlow);\r
+\r
+static void GetFromBigBuf(BYTE *dest, int bytes)\r
+{\r
+ int n = bytes/4;\r
+\r
+ if(n % 48 != 0) {\r
+ PrintToScrollback("bad len in GetFromBigBuf");\r
+ return;\r
+ }\r
+\r
+ int i;\r
+ for(i = 0; i < n; i += 12) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ ReceiveCommand(&c);\r
+ if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
+ PrintToScrollback("bad resp");\r
+ return;\r
+ }\r
+\r
+ memcpy(dest+(i*4), c.d.asBytes, 48);\r
+ }\r
+}\r
+\r
+static void CmdReset(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_HARDWARE_RESET;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdBuffClear(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_BUFF_CLEAR;\r
+ SendCommand(&c, FALSE);\r
+ CmdClearGraph(TRUE);\r
+}\r
+\r
+static void CmdQuit(char *str)\r
+{\r
+ exit(0);\r
+}\r
+\r
+static void CmdHIDdemodFSK(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_HID_DEMOD_FSK;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdTune(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_MEASURE_ANTENNA_TUNING;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi15read(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi14read(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+\r
+/* New command to read the contents of a SRI512 tag\r
+ * SRI512 tags are ISO14443-B modulated memory tags,\r
+ * this command just dumps the contents of the memory/\r
+ */\r
+static void CmdSri512read(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_READ_SRI512_TAG;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+
+/* New command to read the contents of a SRIX4K tag
+ * SRIX4K tags are ISO14443-B modulated memory tags,
+ * this command just dumps the contents of the memory/
+ */
+static void CmdSrix4kread(char *str)
+{
+ UsbCommand c;
+ c.cmd = CMD_READ_SRIX4K_TAG;
+ c.ext1 = atoi(str);
+ SendCommand(&c, FALSE);
+}
+
+
+\r
+// ## New command\r
+static void CmdHi14areader(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_READER_ISO_14443a;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+// ## New command\r
+static void CmdHi15reader(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_READER_ISO_15693;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+// ## New command\r
+static void CmdHi15tag(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SIMTAG_ISO_15693;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi14read_sim(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443_SIM;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi14readt(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+\r
+ //CmdHisamplest(str);\r
+ while(CmdHisamplest(str,atoi(str))==0) {\r
+ c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdHisimlisten(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SIMULATE_TAG_HF_LISTEN;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi14sim(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SIMULATE_TAG_ISO_14443;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi14asim(char *str) // ## simulate iso14443a tag\r
+{ // ## greg - added ability to specify tag UID\r
+\r
+ unsigned int hi=0, lo=0;\r
+ int n=0, i=0;\r
+ UsbCommand c;\r
+\r
+ while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
+ hi=(hi<<4)|(lo>>28);\r
+ lo=(lo<<4)|(n&0xf);\r
+ }\r
+\r
+ c.cmd = CMD_SIMULATE_TAG_ISO_14443a;\r
+ // c.ext should be set to *str or convert *str to the correct format for a uid\r
+ c.ext1 = hi;\r
+ c.ext2 = lo;\r
+ PrintToScrollback("Emulating 14443A TAG with UID %x%16x", hi, lo);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi14snoop(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SNOOP_ISO_14443;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdHi14asnoop(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SNOOP_ISO_14443a;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdLegicRfSim(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SIMULATE_TAG_LEGIC_RF;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdLegicRfRead(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_READER_LEGIC_RF;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdFPGAOff(char *str) // ## FPGA Control\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_FPGA_MAJOR_MODE_OFF;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+/* clear out our graph window */\r
+int CmdClearGraph(int redraw)\r
+{\r
+ int gtl = GraphTraceLen;\r
+ GraphTraceLen = 0;\r
+\r
+ if (redraw)\r
+ RepaintGraphWindow();\r
+\r
+ return gtl;\r
+}\r
+\r
+/* write a bit to the graph */\r
+static void CmdAppendGraph(int redraw, int clock, int bit)\r
+{\r
+ int i;\r
+\r
+ for (i = 0; i < (int)(clock/2); i++)\r
+ GraphBuffer[GraphTraceLen++] = bit ^ 1;\r
+\r
+ for (i = (int)(clock/2); i < clock; i++)\r
+ GraphBuffer[GraphTraceLen++] = bit;\r
+\r
+ if (redraw)\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/* Function is equivalent of loread + losamples + em410xread\r
+ * looped until an EM410x tag is detected */\r
+static void CmdEM410xwatch(char *str)\r
+{\r
+ char *zero = "";\r
+ char *twok = "2000";\r
+ go = 1;\r
+\r
+ do\r
+ {\r
+ CmdLoread(zero);\r
+ CmdLosamples(twok);\r
+ CmdEM410xread(zero);\r
+ } while (go);\r
+}\r
+\r
+/* Read the transmitted data of an EM4x50 tag\r
+ * Format:\r
+ *\r
+ * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
+ * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
+ * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
+ * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
+ * CCCCCCCC <- column parity bits\r
+ * 0 <- stop bit\r
+ * LW <- Listen Window\r
+ *\r
+ * This pattern repeats for every block of data being transmitted.\r
+ * Transmission starts with two Listen Windows (LW - a modulated\r
+ * pattern of 320 cycles each (32/32/128/64/64)).\r
+ *\r
+ * Note that this data may or may not be the UID. It is whatever data\r
+ * is stored in the blocks defined in the control word First and Last\r
+ * Word Read values. UID is stored in block 32.\r
+ */\r
+static void CmdEM4x50read(char *str)\r
+{\r
+ int i, j, startblock, clock, skip, block, start, end, low, high;\r
+ BOOL complete= FALSE;\r
+ int tmpbuff[MAX_GRAPH_TRACE_LEN / 64];\r
+ char tmp[6];\r
+\r
+ high= low= 0;\r
+ clock= 64;\r
+\r
+ /* first get high and low values */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+\r
+ /* populate a buffer with pulse lengths */\r
+ i= 0;\r
+ j= 0;\r
+ while(i < GraphTraceLen)\r
+ {\r
+ // measure from low to low\r
+ while((GraphBuffer[i] > low) && (i<GraphTraceLen))\r
+ ++i;\r
+ start= i;\r
+ while((GraphBuffer[i] < high) && (i<GraphTraceLen))\r
+ ++i;\r
+ while((GraphBuffer[i] > low) && (i<GraphTraceLen))\r
+ ++i;\r
+ if (j>(MAX_GRAPH_TRACE_LEN/64)) {\r
+ break;\r
+ }\r
+ tmpbuff[j++]= i - start;\r
+ }\r
+\r
+ /* look for data start - should be 2 pairs of LW (pulses of 192,128) */\r
+ start= -1;\r
+ skip= 0;\r
+ for (i= 0; i < j - 4 ; ++i)\r
+ {\r
+ skip += tmpbuff[i];\r
+ if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
+ if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
+ if (tmpbuff[i+2] >= 190 && tmpbuff[i+2] <= 194)\r
+ if (tmpbuff[i+3] >= 126 && tmpbuff[i+3] <= 130)\r
+ {\r
+ start= i + 3;\r
+ break;\r
+ }\r
+ }\r
+ startblock= i + 3;\r
+\r
+ /* skip over the remainder of the LW */\r
+ skip += tmpbuff[i+1]+tmpbuff[i+2];\r
+ while(skip < MAX_GRAPH_TRACE_LEN && GraphBuffer[skip] > low)\r
+ ++skip;\r
+ skip += 8;\r
+\r
+ /* now do it again to find the end */\r
+ end= start;\r
+ for (i += 3; i < j - 4 ; ++i)\r
+ {\r
+ end += tmpbuff[i];\r
+ if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
+ if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
+ if (tmpbuff[i+2] >= 190 && tmpbuff[i+2] <= 194)\r
+ if (tmpbuff[i+3] >= 126 && tmpbuff[i+3] <= 130)\r
+ {\r
+ complete= TRUE;\r
+ break;\r
+ }\r
+ }\r
+\r
+ if (start >= 0)\r
+ PrintToScrollback("Found data at sample: %i",skip);\r
+ else\r
+ {\r
+ PrintToScrollback("No data found!");\r
+ PrintToScrollback("Try again with more samples.");\r
+ return;\r
+ }\r
+\r
+ if (!complete)\r
+ {\r
+ PrintToScrollback("*** Warning!");\r
+ PrintToScrollback("Partial data - no end found!");\r
+ PrintToScrollback("Try again with more samples.");\r
+ }\r
+\r
+ /* get rid of leading crap */\r
+ sprintf(tmp,"%i",skip);\r
+ CmdLtrim(tmp);\r
+\r
+ /* now work through remaining buffer printing out data blocks */\r
+ block= 0;\r
+ i= startblock;\r
+ while(block < 6)\r
+ {\r
+ PrintToScrollback("Block %i:", block);\r
+ // mandemod routine needs to be split so we can call it for data\r
+ // just print for now for debugging\r
+ Cmdmanchesterdemod("i 64");\r
+ skip= 0;\r
+ /* look for LW before start of next block */\r
+ for ( ; i < j - 4 ; ++i)\r
+ {\r
+ skip += tmpbuff[i];\r
+ if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
+ if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
+ break;\r
+ }\r
+ while(GraphBuffer[skip] > low)\r
+ ++skip;\r
+ skip += 8;\r
+ sprintf(tmp,"%i",skip);\r
+ CmdLtrim(tmp);\r
+ start += skip;\r
+ block++;\r
+ }\r
+}\r
+\r
+\r
+/* Read the ID of an EM410x tag.\r
+ * Format:\r
+ * 1111 1111 1 <-- standard non-repeatable header\r
+ * XXXX [row parity bit] <-- 10 rows of 5 bits for our 40 bit tag ID\r
+ * ....\r
+ * CCCC <-- each bit here is parity for the 10 bits above in corresponding column\r
+ * 0 <-- stop bit, end of tag\r
+ */\r
+static void CmdEM410xread(char *str)\r
+{\r
+ int i, j, clock, header, rows, bit, hithigh, hitlow, first, bit2idx, high, low;\r
+ int parity[4];\r
+ char id[11];\r
+ int retested = 0;\r
+ int BitStream[MAX_GRAPH_TRACE_LEN];\r
+ high = low = 0;\r
+\r
+ /* Detect high and lows and clock */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+\r
+ /* get clock */\r
+ clock = GetClock(str, high);\r
+\r
+ /* parity for our 4 columns */\r
+ parity[0] = parity[1] = parity[2] = parity[3] = 0;\r
+ header = rows = 0;\r
+\r
+ /* manchester demodulate */\r
+ bit = bit2idx = 0;\r
+ for (i = 0; i < (int)(GraphTraceLen / clock); i++)\r
+ {\r
+ hithigh = 0;\r
+ hitlow = 0;\r
+ first = 1;\r
+\r
+ /* Find out if we hit both high and low peaks */\r
+ for (j = 0; j < clock; j++)\r
+ {\r
+ if (GraphBuffer[(i * clock) + j] == high)\r
+ hithigh = 1;\r
+ else if (GraphBuffer[(i * clock) + j] == low)\r
+ hitlow = 1;\r
+\r
+ /* it doesn't count if it's the first part of our read\r
+ because it's really just trailing from the last sequence */\r
+ if (first && (hithigh || hitlow))\r
+ hithigh = hitlow = 0;\r
+ else\r
+ first = 0;\r
+\r
+ if (hithigh && hitlow)\r
+ break;\r
+ }\r
+\r
+ /* If we didn't hit both high and low peaks, we had a bit transition */\r
+ if (!hithigh || !hitlow)\r
+ bit ^= 1;\r
+\r
+ BitStream[bit2idx++] = bit;\r
+ }\r
+\r
+retest:\r
+ /* We go till 5 before the graph ends because we'll get that far below */\r
+ for (i = 1; i < bit2idx - 5; i++)\r
+ {\r
+ /* Step 2: We have our header but need our tag ID */\r
+ if (header == 9 && rows < 10)\r
+ {\r
+ /* Confirm parity is correct */\r
+ if ((BitStream[i] ^ BitStream[i+1] ^ BitStream[i+2] ^ BitStream[i+3]) == BitStream[i+4])\r
+ {\r
+ /* Read another byte! */\r
+ sprintf(id+rows, "%x", (8 * BitStream[i]) + (4 * BitStream[i+1]) + (2 * BitStream[i+2]) + (1 * BitStream[i+3]));\r
+ rows++;\r
+\r
+ /* Keep parity info */\r
+ parity[0] ^= BitStream[i];\r
+ parity[1] ^= BitStream[i+1];\r
+ parity[2] ^= BitStream[i+2];\r
+ parity[3] ^= BitStream[i+3];\r
+\r
+ /* Move 4 bits ahead */\r
+ i += 4;\r
+ }\r
+\r
+ /* Damn, something wrong! reset */\r
+ else\r
+ {\r
+ PrintToScrollback("Thought we had a valid tag but failed at word %d (i=%d)", rows + 1, i);\r
+\r
+ /* Start back rows * 5 + 9 header bits, -1 to not start at same place */\r
+ i -= 9 + (5 * rows) - 5;\r
+\r
+ rows = header = 0;\r
+ }\r
+ }\r
+\r
+ /* Step 3: Got our 40 bits! confirm column parity */\r
+ else if (rows == 10)\r
+ {\r
+ /* We need to make sure our 4 bits of parity are correct and we have a stop bit */\r
+ if (BitStream[i] == parity[0] && BitStream[i+1] == parity[1] &&\r
+ BitStream[i+2] == parity[2] && BitStream[i+3] == parity[3] &&\r
+ BitStream[i+4] == 0)\r
+ {\r
+ /* Sweet! */\r
+ PrintToScrollback("EM410x Tag ID: %s", id);\r
+\r
+ /* Stop any loops */\r
+ go = 0;\r
+ return;\r
+ }\r
+\r
+ /* Crap! Incorrect parity or no stop bit, start all over */\r
+ else\r
+ {\r
+ rows = header = 0;\r
+\r
+ /* Go back 59 bits (9 header bits + 10 rows at 4+1 parity) */\r
+ i -= 59;\r
+ }\r
+ }\r
+\r
+ /* Step 1: get our header */\r
+ else if (header < 9)\r
+ {\r
+ /* Need 9 consecutive 1's */\r
+ if (BitStream[i] == 1)\r
+ header++;\r
+\r
+ /* We don't have a header, not enough consecutive 1 bits */\r
+ else\r
+ header = 0;\r
+ }\r
+ }\r
+\r
+ /* if we've already retested after flipping bits, return */\r
+ if (retested++)\r
+ return;\r
+\r
+ /* if this didn't work, try flipping bits */\r
+ for (i = 0; i < bit2idx; i++)\r
+ BitStream[i] ^= 1;\r
+\r
+ goto retest;\r
+}\r
+\r
+/* emulate an EM410X tag\r
+ * Format:\r
+ * 1111 1111 1 <-- standard non-repeatable header\r
+ * XXXX [row parity bit] <-- 10 rows of 5 bits for our 40 bit tag ID\r
+ * ....\r
+ * CCCC <-- each bit here is parity for the 10 bits above in corresponding column\r
+ * 0 <-- stop bit, end of tag\r
+ */\r
+static void CmdEM410xsim(char *str)\r
+{\r
+ int i, n, j, h, binary[4], parity[4];\r
+ char *s = "0";\r
+\r
+ /* clock is 64 in EM410x tags */\r
+ int clock = 64;\r
+\r
+ /* clear our graph */\r
+ CmdClearGraph(0);\r
+\r
+ /* write it out a few times */\r
+ for (h = 0; h < 4; h++)\r
+ {\r
+ /* write 9 start bits */\r
+ for (i = 0; i < 9; i++)\r
+ CmdAppendGraph(0, clock, 1);\r
+\r
+ /* for each hex char */\r
+ parity[0] = parity[1] = parity[2] = parity[3] = 0;\r
+ for (i = 0; i < 10; i++)\r
+ {\r
+ /* read each hex char */\r
+ sscanf(&str[i], "%1x", &n);\r
+ for (j = 3; j >= 0; j--, n/= 2)\r
+ binary[j] = n % 2;\r
+\r
+ /* append each bit */\r
+ CmdAppendGraph(0, clock, binary[0]);\r
+ CmdAppendGraph(0, clock, binary[1]);\r
+ CmdAppendGraph(0, clock, binary[2]);\r
+ CmdAppendGraph(0, clock, binary[3]);\r
+\r
+ /* append parity bit */\r
+ CmdAppendGraph(0, clock, binary[0] ^ binary[1] ^ binary[2] ^ binary[3]);\r
+\r
+ /* keep track of column parity */\r
+ parity[0] ^= binary[0];\r
+ parity[1] ^= binary[1];\r
+ parity[2] ^= binary[2];\r
+ parity[3] ^= binary[3];\r
+ }\r
+\r
+ /* parity columns */\r
+ CmdAppendGraph(0, clock, parity[0]);\r
+ CmdAppendGraph(0, clock, parity[1]);\r
+ CmdAppendGraph(0, clock, parity[2]);\r
+ CmdAppendGraph(0, clock, parity[3]);\r
+\r
+ /* stop bit */\r
+ CmdAppendGraph(0, clock, 0);\r
+ }\r
+\r
+ /* modulate that biatch */\r
+ Cmdmanchestermod(s);\r
+\r
+ /* booyah! */\r
+ RepaintGraphWindow();\r
+\r
+ CmdLosim(s);\r
+}\r
+\r
+static void ChkBitstream(char *str)\r
+{\r
+ int i;\r
+\r
+ /* convert to bitstream if necessary */\r
+ for (i = 0; i < (int)(GraphTraceLen / 2); i++)\r
+ {\r
+ if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0)\r
+ {\r
+ Cmdbitstream(str);\r
+ break;\r
+ }\r
+ }\r
+}\r
+\r
+static void CmdLosim(char *str)\r
+{\r
+ int i;\r
+\r
+ /* convert to bitstream if necessary */\r
+ ChkBitstream(str);\r
+\r
+ for (i = 0; i < GraphTraceLen; i += 48) {\r
+ UsbCommand c;\r
+ int j;\r
+ for(j = 0; j < 48; j++) {\r
+ c.d.asBytes[j] = GraphBuffer[i+j];\r
+ }\r
+ c.cmd = CMD_DOWNLOADED_SIM_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ }\r
+\r
+ UsbCommand c;\r
+ c.cmd = CMD_SIMULATE_TAG_125K;\r
+ c.ext1 = GraphTraceLen;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdLosimBidir(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_LF_SIMULATE_BIDIR;\r
+ c.ext1 = 47; /* Set ADC to twice the carrier for a slight supersampling */\r
+ c.ext2 = 384;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdLoread(char *str)\r
+{\r
+ UsbCommand c;\r
+ // 'h' means higher-low-frequency, 134 kHz\r
+ if(*str == 'h') {\r
+ c.ext1 = 1;\r
+ } else if (*str == '\0') {\r
+ c.ext1 = 0;\r
+ } else {\r
+ PrintToScrollback("use 'loread' or 'loread h'");\r
+ return;\r
+ }\r
+ c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_125K;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdDetectReader(char *str)\r
+{\r
+ UsbCommand c;\r
+ // 'l' means LF - 125/134 kHz\r
+ if(*str == 'l') {\r
+ c.ext1 = 1;\r
+ } else if (*str == 'h') {\r
+ c.ext1 = 2;\r
+ } else if (*str != '\0') {\r
+ PrintToScrollback("use 'detectreader' or 'detectreader l' or 'detectreader h'");\r
+ return;\r
+ }\r
+ c.cmd = CMD_LISTEN_READER_FIELD;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+/* send a command before reading */\r
+static void CmdLoCommandRead(char *str)\r
+{\r
+ static char dummy[3];\r
+\r
+ dummy[0]= ' ';\r
+\r
+ UsbCommand c;\r
+ c.cmd = CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K;\r
+ sscanf(str, "%i %i %i %s %s", &c.ext1, &c.ext2, &c.ext3, (char *) &c.d.asBytes,(char *) &dummy+1);\r
+ // in case they specified 'h'\r
+ strcpy((char *)&c.d.asBytes + strlen((char *)c.d.asBytes), dummy);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdLosamples(char *str)\r
+{\r
+ int cnt = 0;\r
+ int i;\r
+ int n;\r
+\r
+ n=atoi(str);\r
+ if (n==0) n=128;\r
+ if (n>16000) n=16000;\r
+\r
+ for(i = 0; i < n; i += 12) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ ReceiveCommand(&c);\r
+ if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
+ if (!go)\r
+ PrintToScrollback("bad resp");\r
+ return;\r
+ }\r
+ int j;\r
+ for(j = 0; j < 48; j++) {\r
+ GraphBuffer[cnt++] = ((int)c.d.asBytes[j]) - 128;\r
+ }\r
+ }\r
+ GraphTraceLen = n*4;\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdBitsamples(char *str)\r
+{\r
+ int cnt = 0;\r
+ int i;\r
+ int n;\r
+\r
+ n = 3072;\r
+ for(i = 0; i < n; i += 12) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ ReceiveCommand(&c);\r
+ if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
+ PrintToScrollback("bad resp");\r
+ return;\r
+ }\r
+ int j, k;\r
+ for(j = 0; j < 48; j++) {\r
+ for(k = 0; k < 8; k++) {\r
+ if(c.d.asBytes[j] & (1 << (7 - k))) {\r
+ GraphBuffer[cnt++] = 1;\r
+ } else {\r
+ GraphBuffer[cnt++] = 0;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ GraphTraceLen = cnt;\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdHisamples(char *str)\r
+{\r
+ int cnt = 0;\r
+ int i;\r
+ int n;\r
+ n = 1000;\r
+ for(i = 0; i < n; i += 12) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ ReceiveCommand(&c);\r
+ if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
+ PrintToScrollback("bad resp");\r
+ return;\r
+ }\r
+ int j;\r
+ for(j = 0; j < 48; j++) {\r
+ GraphBuffer[cnt++] = (int)((BYTE)c.d.asBytes[j]);\r
+ }\r
+ }\r
+ GraphTraceLen = n*4;\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static int CmdHisamplest(char *str, int nrlow)\r
+{\r
+ int cnt = 0;\r
+ int t1, t2;\r
+ int i;\r
+ int n;\r
+ int hasbeennull;\r
+ int show;\r
+\r
+\r
+ n = 1000;\r
+ hasbeennull = 0;\r
+ for(i = 0; i < n; i += 12) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ ReceiveCommand(&c);\r
+ if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
+ PrintToScrollback("bad resp");\r
+ return 0;\r
+ }\r
+ int j;\r
+ for(j = 0; j < 48; j++) {\r
+ t2 = (int)((BYTE)c.d.asBytes[j]);\r
+ if((t2 ^ 0xC0) & 0xC0) { hasbeennull++; }\r
+\r
+ show = 0;\r
+ switch(show) {\r
+ case 0:\r
+ // combined\r
+ t1 = (t2 & 0x80) ^ (t2 & 0x20);\r
+ t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x20);\r
+ break;\r
+\r
+ case 1:\r
+ // only reader\r
+ t1 = (t2 & 0x80);\r
+ t2 = ((t2 << 1) & 0x80);\r
+ break;\r
+\r
+ case 2:\r
+ // only tag\r
+ t1 = (t2 & 0x20);\r
+ t2 = ((t2 << 1) & 0x20);\r
+ break;\r
+\r
+ case 3:\r
+ // both, but tag with other algorithm\r
+ t1 = (t2 & 0x80) ^ (t2 & 0x08);\r
+ t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x08);\r
+ break;\r
+ }\r
+\r
+ GraphBuffer[cnt++] = t1;\r
+ GraphBuffer[cnt++] = t2;\r
+ }\r
+ }\r
+ GraphTraceLen = n*4;\r
+// 1130\r
+ if(hasbeennull>nrlow || nrlow==0) {\r
+ PrintToScrollback("hasbeennull=%d", hasbeennull);\r
+ return 1;\r
+ }\r
+ else {\r
+ return 0;\r
+ }\r
+}\r
+\r
+\r
+static void CmdHexsamples(char *str)\r
+{\r
+ int i;\r
+ int n;\r
+ int requested = atoi(str);\r
+ int delivered = 0;\r
+\r
+ if(atoi(str) == 0) {\r
+ n = 12;\r
+ requested = 12;\r
+ } else {\r
+ n = atoi(str)/4;\r
+ }\r
+\r
+ for(i = 0; i < n; i += 12) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ ReceiveCommand(&c);\r
+ if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
+ PrintToScrollback("bad resp");\r
+ return;\r
+ }\r
+ int j;\r
+ for(j = 0; j < 48; j += 8) {\r
+ PrintToScrollback("%02x %02x %02x %02x %02x %02x %02x %02x",\r
+ c.d.asBytes[j+0],\r
+ c.d.asBytes[j+1],\r
+ c.d.asBytes[j+2],\r
+ c.d.asBytes[j+3],\r
+ c.d.asBytes[j+4],\r
+ c.d.asBytes[j+5],\r
+ c.d.asBytes[j+6],\r
+ c.d.asBytes[j+7],\r
+ c.d.asBytes[j+8]\r
+ );\r
+ delivered += 8;\r
+ if(delivered >= requested)\r
+ break;\r
+ }\r
+ if(delivered >= requested)\r
+ break;\r
+ }\r
+}\r
+\r
+static void CmdHisampless(char *str)\r
+{\r
+ int cnt = 0;\r
+ int i;\r
+ int n;\r
+\r
+ if(atoi(str) == 0) {\r
+ n = 1000;\r
+ } else {\r
+ n = atoi(str)/4;\r
+ }\r
+\r
+ for(i = 0; i < n; i += 12) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
+ c.ext1 = i;\r
+ SendCommand(&c, FALSE);\r
+ ReceiveCommand(&c);\r
+ if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
+ PrintToScrollback("bad resp");\r
+ return;\r
+ }\r
+ int j;\r
+ for(j = 0; j < 48; j++) {\r
+ GraphBuffer[cnt++] = (int)((signed char)c.d.asBytes[j]);\r
+ }\r
+ }\r
+ GraphTraceLen = cnt;\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static WORD Iso15693Crc(BYTE *v, int n)\r
+{\r
+ DWORD reg;\r
+ int i, j;\r
+\r
+ reg = 0xffff;\r
+ for(i = 0; i < n; i++) {\r
+ reg = reg ^ ((DWORD)v[i]);\r
+ for (j = 0; j < 8; j++) {\r
+ if (reg & 0x0001) {\r
+ reg = (reg >> 1) ^ 0x8408;\r
+ } else {\r
+ reg = (reg >> 1);\r
+ }\r
+ }\r
+ }\r
+\r
+ return (WORD)~reg;\r
+}\r
+\r
+static void CmdHi14bdemod(char *str)\r
+{\r
+ int i, j, iold;\r
+ int isum, qsum;\r
+ int outOfWeakAt;\r
+ BOOL negateI, negateQ;\r
+\r
+ BYTE data[256];\r
+ int dataLen=0;\r
+\r
+ // As received, the samples are pairs, correlations against I and Q\r
+ // square waves. So estimate angle of initial carrier (or just\r
+ // quadrant, actually), and then do the demod.\r
+\r
+ // First, estimate where the tag starts modulating.\r
+ for(i = 0; i < GraphTraceLen; i += 2) {\r
+ if(abs(GraphBuffer[i]) + abs(GraphBuffer[i+1]) > 40) {\r
+ break;\r
+ }\r
+ }\r
+ if(i >= GraphTraceLen) {\r
+ PrintToScrollback("too weak to sync");\r
+ return;\r
+ }\r
+ PrintToScrollback("out of weak at %d", i);\r
+ outOfWeakAt = i;\r
+\r
+ // Now, estimate the phase in the initial modulation of the tag\r
+ isum = 0;\r
+ qsum = 0;\r
+ for(; i < (outOfWeakAt + 16); i += 2) {\r
+ isum += GraphBuffer[i+0];\r
+ qsum += GraphBuffer[i+1];\r
+ }\r
+ negateI = (isum < 0);\r
+ negateQ = (qsum < 0);\r
+\r
+ // Turn the correlation pairs into soft decisions on the bit.\r
+ j = 0;\r
+ for(i = 0; i < GraphTraceLen/2; i++) {\r
+ int si = GraphBuffer[j];\r
+ int sq = GraphBuffer[j+1];\r
+ if(negateI) si = -si;\r
+ if(negateQ) sq = -sq;\r
+ GraphBuffer[i] = si + sq;\r
+ j += 2;\r
+ }\r
+ GraphTraceLen = i;\r
+\r
+ i = outOfWeakAt/2;\r
+ while(GraphBuffer[i] > 0 && i < GraphTraceLen)\r
+ i++;\r
+ if(i >= GraphTraceLen) goto demodError;\r
+\r
+ iold = i;\r
+ while(GraphBuffer[i] < 0 && i < GraphTraceLen)\r
+ i++;\r
+ if(i >= GraphTraceLen) goto demodError;\r
+ if((i - iold) > 23) goto demodError;\r
+\r
+ PrintToScrollback("make it to demod loop");\r
+\r
+ for(;;) {\r
+ iold = i;\r
+ while(GraphBuffer[i] >= 0 && i < GraphTraceLen)\r
+ i++;\r
+ if(i >= GraphTraceLen) goto demodError;\r
+ if((i - iold) > 6) goto demodError;\r
+\r
+ WORD shiftReg = 0;\r
+ if(i + 20 >= GraphTraceLen) goto demodError;\r
+\r
+ for(j = 0; j < 10; j++) {\r
+ int soft = GraphBuffer[i] + GraphBuffer[i+1];\r
+\r
+ if(abs(soft) < ((abs(isum) + abs(qsum))/20)) {\r
+ PrintToScrollback("weak bit");\r
+ }\r
+\r
+ shiftReg >>= 1;\r
+ if(GraphBuffer[i] + GraphBuffer[i+1] >= 0) {\r
+ shiftReg |= 0x200;\r
+ }\r
+\r
+ i+= 2;\r
+ }\r
+\r
+ if( (shiftReg & 0x200) &&\r
+ !(shiftReg & 0x001))\r
+ {\r
+ // valid data byte, start and stop bits okay\r
+ PrintToScrollback(" %02x", (shiftReg >> 1) & 0xff);\r
+ data[dataLen++] = (shiftReg >> 1) & 0xff;\r
+ if(dataLen >= sizeof(data)) {\r
+ return;\r
+ }\r
+ } else if(shiftReg == 0x000) {\r
+ // this is EOF\r
+ break;\r
+ } else {\r
+ goto demodError;\r
+ }\r
+ }\r
+\r
+ BYTE first, second;\r
+ ComputeCrc14443(CRC_14443_B, data, dataLen-2, &first, &second);\r
+ PrintToScrollback("CRC: %02x %02x (%s)\n", first, second,\r
+ (first == data[dataLen-2] && second == data[dataLen-1]) ?\r
+ "ok" : "****FAIL****");\r
+\r
+ RepaintGraphWindow();\r
+ return;\r
+\r
+demodError:\r
+ PrintToScrollback("demod error");\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdHi14list(char *str)\r
+{\r
+ BYTE got[960];\r
+ GetFromBigBuf(got, sizeof(got));\r
+\r
+ PrintToScrollback("recorded activity:");\r
+ PrintToScrollback(" time :rssi: who bytes");\r
+ PrintToScrollback("---------+----+----+-----------");\r
+\r
+ int i = 0;\r
+ int prev = -1;\r
+\r
+ for(;;) {\r
+ if(i >= 900) {\r
+ break;\r
+ }\r
+\r
+ BOOL isResponse;\r
+ int timestamp = *((DWORD *)(got+i));\r
+ if(timestamp & 0x80000000) {\r
+ timestamp &= 0x7fffffff;\r
+ isResponse = 1;\r
+ } else {\r
+ isResponse = 0;\r
+ }\r
+ int metric = *((DWORD *)(got+i+4));\r
+\r
+ int len = got[i+8];\r
+\r
+ if(len > 100) {\r
+ break;\r
+ }\r
+ if(i + len >= 900) {\r
+ break;\r
+ }\r
+\r
+ BYTE *frame = (got+i+9);\r
+\r
+ char line[1000] = "";\r
+ int j;\r
+ for(j = 0; j < len; j++) {\r
+ sprintf(line+(j*3), "%02x ", frame[j]);\r
+ }\r
+\r
+ char *crc;\r
+ if(len > 2) {\r
+ BYTE b1, b2;\r
+ ComputeCrc14443(CRC_14443_B, frame, len-2, &b1, &b2);\r
+ if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
+ crc = "**FAIL CRC**";\r
+ } else {\r
+ crc = "";\r
+ }\r
+ } else {\r
+ crc = "(SHORT)";\r
+ }\r
+\r
+ char metricString[100];\r
+ if(isResponse) {\r
+ sprintf(metricString, "%3d", metric);\r
+ } else {\r
+ strcpy(metricString, " ");\r
+ }\r
+\r
+ PrintToScrollback(" +%7d: %s: %s %s %s",\r
+ (prev < 0 ? 0 : timestamp - prev),\r
+ metricString,\r
+ (isResponse ? "TAG" : " "), line, crc);\r
+\r
+ prev = timestamp;\r
+ i += (len + 9);\r
+ }\r
+}\r
+\r
+static void CmdHi14alist(char *str)\r
+{\r
+ BYTE got[1920];\r
+ GetFromBigBuf(got, sizeof(got));\r
+\r
+ PrintToScrollback("recorded activity:");\r
+ PrintToScrollback(" ETU :rssi: who bytes");\r
+ PrintToScrollback("---------+----+----+-----------");\r
+\r
+ int i = 0;\r
+ int prev = -1;\r
+\r
+ for(;;) {\r
+ if(i >= 1900) {\r
+ break;\r
+ }\r
+\r
+ BOOL isResponse;\r
+ int timestamp = *((DWORD *)(got+i));\r
+ if(timestamp & 0x80000000) {\r
+ timestamp &= 0x7fffffff;\r
+ isResponse = 1;\r
+ } else {\r
+ isResponse = 0;\r
+ }\r
+\r
+ int metric = 0;\r
+ int parityBits = *((DWORD *)(got+i+4));\r
+ // 4 bytes of additional information...\r
+ // maximum of 32 additional parity bit information\r
+ //\r
+ // TODO:\r
+ // at each quarter bit period we can send power level (16 levels)\r
+ // or each half bit period in 256 levels.\r
+\r
+\r
+ int len = got[i+8];\r
+\r
+ if(len > 100) {\r
+ break;\r
+ }\r
+ if(i + len >= 1900) {\r
+ break;\r
+ }\r
+\r
+ BYTE *frame = (got+i+9);\r
+\r
+ // Break and stick with current result if buffer was not completely full\r
+ if(frame[0] == 0x44 && frame[1] == 0x44 && frame[3] == 0x44) { break; }\r
+\r
+ char line[1000] = "";\r
+ int j;\r
+ for(j = 0; j < len; j++) {\r
+ int oddparity = 0x01;\r
+ int k;\r
+\r
+ for(k=0;k<8;k++) {\r
+ oddparity ^= (((frame[j] & 0xFF) >> k) & 0x01);\r
+ }\r
+\r
+ //if((parityBits >> (len - j - 1)) & 0x01) {\r
+ if(isResponse && (oddparity != ((parityBits >> (len - j - 1)) & 0x01))) {\r
+ sprintf(line+(j*4), "%02x! ", frame[j]);\r
+ }\r
+ else {\r
+ sprintf(line+(j*4), "%02x ", frame[j]);\r
+ }\r
+ }\r
+\r
+ char *crc;\r
+ crc = "";\r
+ if(len > 2) {\r
+ BYTE b1, b2;\r
+ for(j = 0; j < (len - 1); j++) {\r
+ // gives problems... search for the reason..\r
+ /*if(frame[j] == 0xAA) {\r
+ switch(frame[j+1]) {\r
+ case 0x01:\r
+ crc = "[1] Two drops close after each other";\r
+ break;\r
+ case 0x02:\r
+ crc = "[2] Potential SOC with a drop in second half of bitperiod";\r
+ break;\r
+ case 0x03:\r
+ crc = "[3] Segment Z after segment X is not possible";\r
+ break;\r
+ case 0x04:\r
+ crc = "[4] Parity bit of a fully received byte was wrong";\r
+ break;\r
+ default:\r
+ crc = "[?] Unknown error";\r
+ break;\r
+ }\r
+ break;\r
+ }*/\r
+ }\r
+\r
+ if(strlen(crc)==0) {\r
+ ComputeCrc14443(CRC_14443_A, frame, len-2, &b1, &b2);\r
+ if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
+ crc = (isResponse & (len < 6)) ? "" : " !crc";\r
+ } else {\r
+ crc = "";\r
+ }\r
+ }\r
+ } else {\r
+ crc = ""; // SHORT\r
+ }\r
+\r
+ char metricString[100];\r
+ if(isResponse) {\r
+ sprintf(metricString, "%3d", metric);\r
+ } else {\r
+ strcpy(metricString, " ");\r
+ }\r
+\r
+ PrintToScrollback(" +%7d: %s: %s %s %s",\r
+ (prev < 0 ? 0 : (timestamp - prev)),\r
+ metricString,\r
+ (isResponse ? "TAG" : " "), line, crc);\r
+\r
+ prev = timestamp;\r
+ i += (len + 9);\r
+ }\r
+ CommandFinished = 1;\r
+}\r
+\r
+static void CmdHi15demod(char *str)\r
+{\r
+ // The sampling rate is 106.353 ksps/s, for T = 18.8 us\r
+\r
+ // SOF defined as\r
+ // 1) Unmodulated time of 56.64us\r
+ // 2) 24 pulses of 423.75khz\r
+ // 3) logic '1' (unmodulated for 18.88us followed by 8 pulses of 423.75khz)\r
+\r
+ static const int FrameSOF[] = {\r
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ -1, -1, -1, -1,\r
+ -1, -1, -1, -1,\r
+ 1, 1, 1, 1,\r
+ 1, 1, 1, 1\r
+ };\r
+ static const int Logic0[] = {\r
+ 1, 1, 1, 1,\r
+ 1, 1, 1, 1,\r
+ -1, -1, -1, -1,\r
+ -1, -1, -1, -1\r
+ };\r
+ static const int Logic1[] = {\r
+ -1, -1, -1, -1,\r
+ -1, -1, -1, -1,\r
+ 1, 1, 1, 1,\r
+ 1, 1, 1, 1\r
+ };\r
+\r
+ // EOF defined as\r
+ // 1) logic '0' (8 pulses of 423.75khz followed by unmodulated for 18.88us)\r
+ // 2) 24 pulses of 423.75khz\r
+ // 3) Unmodulated time of 56.64us\r
+\r
+ static const int FrameEOF[] = {\r
+ 1, 1, 1, 1,\r
+ 1, 1, 1, 1,\r
+ -1, -1, -1, -1,\r
+ -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1\r
+ };\r
+\r
+ int i, j;\r
+ int max = 0, maxPos;\r
+\r
+ int skip = 4;\r
+\r
+ if(GraphTraceLen < 1000) return;\r
+\r
+ // First, correlate for SOF\r
+ for(i = 0; i < 100; i++) {\r
+ int corr = 0;\r
+ for(j = 0; j < arraylen(FrameSOF); j += skip) {\r
+ corr += FrameSOF[j]*GraphBuffer[i+(j/skip)];\r
+ }\r
+ if(corr > max) {\r
+ max = corr;\r
+ maxPos = i;\r
+ }\r
+ }\r
+ PrintToScrollback("SOF at %d, correlation %d", maxPos,\r
+ max/(arraylen(FrameSOF)/skip));\r
+\r
+ i = maxPos + arraylen(FrameSOF)/skip;\r
+ int k = 0;\r
+ BYTE outBuf[20];\r
+ memset(outBuf, 0, sizeof(outBuf));\r
+ BYTE mask = 0x01;\r
+ for(;;) {\r
+ int corr0 = 0, corr1 = 0, corrEOF = 0;\r
+ for(j = 0; j < arraylen(Logic0); j += skip) {\r
+ corr0 += Logic0[j]*GraphBuffer[i+(j/skip)];\r
+ }\r
+ for(j = 0; j < arraylen(Logic1); j += skip) {\r
+ corr1 += Logic1[j]*GraphBuffer[i+(j/skip)];\r
+ }\r
+ for(j = 0; j < arraylen(FrameEOF); j += skip) {\r
+ corrEOF += FrameEOF[j]*GraphBuffer[i+(j/skip)];\r
+ }\r
+ // Even things out by the length of the target waveform.\r
+ corr0 *= 4;\r
+ corr1 *= 4;\r
+\r
+ if(corrEOF > corr1 && corrEOF > corr0) {\r
+ PrintToScrollback("EOF at %d", i);\r
+ break;\r
+ } else if(corr1 > corr0) {\r
+ i += arraylen(Logic1)/skip;\r
+ outBuf[k] |= mask;\r
+ } else {\r
+ i += arraylen(Logic0)/skip;\r
+ }\r
+ mask <<= 1;\r
+ if(mask == 0) {\r
+ k++;\r
+ mask = 0x01;\r
+ }\r
+ if((i+(int)arraylen(FrameEOF)) >= GraphTraceLen) {\r
+ PrintToScrollback("ran off end!");\r
+ break;\r
+ }\r
+ }\r
+ if(mask != 0x01) {\r
+ PrintToScrollback("error, uneven octet! (discard extra bits!)");\r
+ PrintToScrollback(" mask=%02x", mask);\r
+ }\r
+ PrintToScrollback("%d octets", k);\r
+\r
+ for(i = 0; i < k; i++) {\r
+ PrintToScrollback("# %2d: %02x ", i, outBuf[i]);\r
+ }\r
+ PrintToScrollback("CRC=%04x", Iso15693Crc(outBuf, k-2));\r
+}\r
+\r
+static void CmdFSKdemod(char *cmdline)\r
+{\r
+ static const int LowTone[] = {\r
+ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1\r
+ };\r
+ static const int HighTone[] = {\r
+ 1, 1, 1, 1, 1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
+ };\r
+\r
+ int lowLen = sizeof(LowTone)/sizeof(int);\r
+ int highLen = sizeof(HighTone)/sizeof(int);\r
+ int convLen = (highLen>lowLen)?highLen:lowLen;\r
+ DWORD hi = 0, lo = 0;\r
+\r
+ int i, j;\r
+ int minMark=0, maxMark=0;\r
+\r
+ for(i = 0; i < GraphTraceLen - convLen; i++) {\r
+ int lowSum = 0, highSum = 0;\r
+\r
+ for(j = 0; j < lowLen; j++) {\r
+ lowSum += LowTone[j]*GraphBuffer[i+j];\r
+ }\r
+ for(j = 0; j < highLen; j++) {\r
+ highSum += HighTone[j]*GraphBuffer[i+j];\r
+ }\r
+ lowSum = abs((100*lowSum) / lowLen);\r
+ highSum = abs((100*highSum) / highLen);\r
+ GraphBuffer[i] = (highSum << 16) | lowSum;\r
+ }\r
+\r
+ for(i = 0; i < GraphTraceLen - convLen - 16; i++) {\r
+ int j;\r
+ int lowTot = 0, highTot = 0;\r
+ // 10 and 8 are f_s divided by f_l and f_h, rounded\r
+ for(j = 0; j < 10; j++) {\r
+ lowTot += (GraphBuffer[i+j] & 0xffff);\r
+ }\r
+ for(j = 0; j < 8; j++) {\r
+ highTot += (GraphBuffer[i+j] >> 16);\r
+ }\r
+ GraphBuffer[i] = lowTot - highTot;\r
+ if (GraphBuffer[i]>maxMark) maxMark=GraphBuffer[i];\r
+ if (GraphBuffer[i]<minMark) minMark=GraphBuffer[i];\r
+ }\r
+\r
+ GraphTraceLen -= (convLen + 16);\r
+\r
+ RepaintGraphWindow();\r
+\r
+ // Find bit-sync (3 lo followed by 3 high)\r
+ int max = 0, maxPos = 0;\r
+ for(i = 0; i < 6000; i++) {\r
+ int dec = 0;\r
+ for(j = 0; j < 3*lowLen; j++) {\r
+ dec -= GraphBuffer[i+j];\r
+ }\r
+ for(; j < 3*(lowLen + highLen ); j++) {\r
+ dec += GraphBuffer[i+j];\r
+ }\r
+ if(dec > max) {\r
+ max = dec;\r
+ maxPos = i;\r
+ }\r
+ }\r
+\r
+ // place start of bit sync marker in graph\r
+ GraphBuffer[maxPos] = maxMark;\r
+ GraphBuffer[maxPos+1] = minMark;\r
+\r
+ maxPos += j;\r
+\r
+ // place end of bit sync marker in graph\r
+ GraphBuffer[maxPos] = maxMark;\r
+ GraphBuffer[maxPos+1] = minMark;\r
+\r
+ PrintToScrollback("actual data bits start at sample %d", maxPos);\r
+ PrintToScrollback("length %d/%d", highLen, lowLen);\r
+\r
+ BYTE bits[46];\r
+ bits[sizeof(bits)-1] = '\0';\r
+\r
+ // find bit pairs and manchester decode them\r
+ for(i = 0; i < arraylen(bits)-1; i++) {\r
+ int dec = 0;\r
+ for(j = 0; j < lowLen; j++) {\r
+ dec -= GraphBuffer[maxPos+j];\r
+ }\r
+ for(; j < lowLen + highLen; j++) {\r
+ dec += GraphBuffer[maxPos+j];\r
+ }\r
+ maxPos += j;\r
+ // place inter bit marker in graph\r
+ GraphBuffer[maxPos] = maxMark;\r
+ GraphBuffer[maxPos+1] = minMark;\r
+\r
+ // hi and lo form a 64 bit pair\r
+ hi = (hi<<1)|(lo>>31);\r
+ lo = (lo<<1);\r
+ // store decoded bit as binary (in hi/lo) and text (in bits[])\r
+ if(dec<0) {\r
+ bits[i] = '1';\r
+ lo|=1;\r
+ } else {\r
+ bits[i] = '0';\r
+ }\r
+ }\r
+ PrintToScrollback("bits: '%s'", bits);\r
+ PrintToScrollback("hex: %08x %08x", hi, lo);\r
+}\r
+\r
+// read a TI tag and return its ID\r
+static void CmdTIRead(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_READ_TI_TYPE;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+// write new data to a r/w TI tag\r
+static void CmdTIWrite(char *str)\r
+{\r
+ UsbCommand c;\r
+ int res=0;\r
+\r
+ c.cmd = CMD_WRITE_TI_TYPE;\r
+ res = sscanf(str, "0x%x 0x%x 0x%x ", &c.ext1, &c.ext2, &c.ext3);\r
+ if (res == 2) c.ext3=0;\r
+ if (res<2)\r
+ PrintToScrollback("Please specify the data as two hex strings, optionally the CRC as a third");\r
+ else\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdTIDemod(char *cmdline)\r
+{\r
+ /* MATLAB as follows:\r
+f_s = 2000000; % sampling frequency\r
+f_l = 123200; % low FSK tone\r
+f_h = 134200; % high FSK tone\r
+\r
+T_l = 119e-6; % low bit duration\r
+T_h = 130e-6; % high bit duration\r
+\r
+l = 2*pi*ones(1, floor(f_s*T_l))*(f_l/f_s);\r
+h = 2*pi*ones(1, floor(f_s*T_h))*(f_h/f_s);\r
+\r
+l = sign(sin(cumsum(l)));\r
+h = sign(sin(cumsum(h)));\r
+ */\r
+\r
+// 2M*16/134.2k = 238\r
+ static const int LowTone[] = {\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1\r
+ };\r
+// 2M*16/123.2k = 260\r
+ static const int HighTone[] = {\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1\r
+ };\r
+ int lowLen = sizeof(LowTone)/sizeof(int);\r
+ int highLen = sizeof(HighTone)/sizeof(int);\r
+ int convLen = (highLen>lowLen)?highLen:lowLen;\r
+ WORD crc;\r
+ int i, j, TagType;\r
+ int lowSum = 0, highSum = 0;;\r
+ int lowTot = 0, highTot = 0;\r
+\r
+ for(i = 0; i < GraphTraceLen - convLen; i++) {\r
+ lowSum = 0;\r
+ highSum = 0;;\r
+\r
+ for(j = 0; j < lowLen; j++) {\r
+ lowSum += LowTone[j]*GraphBuffer[i+j];\r
+ }\r
+ for(j = 0; j < highLen; j++) {\r
+ highSum += HighTone[j]*GraphBuffer[i+j];\r
+ }\r
+ lowSum = abs((100*lowSum) / lowLen);\r
+ highSum = abs((100*highSum) / highLen);\r
+ lowSum = (lowSum<0)?-lowSum:lowSum;\r
+ highSum = (highSum<0)?-highSum:highSum;\r
+\r
+ GraphBuffer[i] = (highSum << 16) | lowSum;\r
+ }\r
+\r
+ for(i = 0; i < GraphTraceLen - convLen - 16; i++) {\r
+ lowTot = 0;\r
+ highTot = 0;\r
+ // 16 and 15 are f_s divided by f_l and f_h, rounded\r
+ for(j = 0; j < 16; j++) {\r
+ lowTot += (GraphBuffer[i+j] & 0xffff);\r
+ }\r
+ for(j = 0; j < 15; j++) {\r
+ highTot += (GraphBuffer[i+j] >> 16);\r
+ }\r
+ GraphBuffer[i] = lowTot - highTot;\r
+ }\r
+\r
+ GraphTraceLen -= (convLen + 16);\r
+\r
+ RepaintGraphWindow();\r
+\r
+ // TI tag data format is 16 prebits, 8 start bits, 64 data bits,\r
+ // 16 crc CCITT bits, 8 stop bits, 15 end bits\r
+\r
+ // the 16 prebits are always low\r
+ // the 8 start and stop bits of a tag must match\r
+ // the start/stop prebits of a ro tag are 01111110\r
+ // the start/stop prebits of a rw tag are 11111110\r
+ // the 15 end bits of a ro tag are all low\r
+ // the 15 end bits of a rw tag match bits 15-1 of the data bits\r
+\r
+ // Okay, so now we have unsliced soft decisions;\r
+ // find bit-sync, and then get some bits.\r
+ // look for 17 low bits followed by 6 highs (common pattern for ro and rw tags)\r
+ int max = 0, maxPos = 0;\r
+ for(i = 0; i < 6000; i++) {\r
+ int j;\r
+ int dec = 0;\r
+ // searching 17 consecutive lows\r
+ for(j = 0; j < 17*lowLen; j++) {\r
+ dec -= GraphBuffer[i+j];\r
+ }\r
+ // searching 7 consecutive highs\r
+ for(; j < 17*lowLen + 6*highLen; j++) {\r
+ dec += GraphBuffer[i+j];\r
+ }\r
+ if(dec > max) {\r
+ max = dec;\r
+ maxPos = i;\r
+ }\r
+ }\r
+\r
+ // place a marker in the buffer to visually aid location\r
+ // of the start of sync\r
+ GraphBuffer[maxPos] = 800;\r
+ GraphBuffer[maxPos+1] = -800;\r
+\r
+ // advance pointer to start of actual data stream (after 16 pre and 8 start bits)\r
+ maxPos += 17*lowLen;\r
+ maxPos += 6*highLen;\r
+\r
+ // place a marker in the buffer to visually aid location\r
+ // of the end of sync\r
+ GraphBuffer[maxPos] = 800;\r
+ GraphBuffer[maxPos+1] = -800;\r
+\r
+ PrintToScrollback("actual data bits start at sample %d", maxPos);\r
+\r
+ PrintToScrollback("length %d/%d", highLen, lowLen);\r
+\r
+ BYTE bits[1+64+16+8+16];\r
+ bits[sizeof(bits)-1] = '\0';\r
+\r
+ DWORD shift3 = 0x7e000000, shift2 = 0, shift1 = 0, shift0 = 0;\r
+\r
+ for(i = 0; i < arraylen(bits)-1; i++) {\r
+ int high = 0;\r
+ int low = 0;\r
+ int j;\r
+ for(j = 0; j < lowLen; j++) {\r
+ low -= GraphBuffer[maxPos+j];\r
+ }\r
+ for(j = 0; j < highLen; j++) {\r
+ high += GraphBuffer[maxPos+j];\r
+ }\r
+\r
+ if(high > low) {\r
+ bits[i] = '1';\r
+ maxPos += highLen;\r
+ // bitstream arrives lsb first so shift right\r
+ shift3 |= (1<<31);\r
+ } else {\r
+ bits[i] = '.';\r
+ maxPos += lowLen;\r
+ }\r
+\r
+ // 128 bit right shift register\r
+ shift0 = (shift0>>1) | (shift1 << 31);\r
+ shift1 = (shift1>>1) | (shift2 << 31);\r
+ shift2 = (shift2>>1) | (shift3 << 31);\r
+ shift3 >>= 1;\r
+\r
+ // place a marker in the buffer between bits to visually aid location\r
+ GraphBuffer[maxPos] = 800;\r
+ GraphBuffer[maxPos+1] = -800;\r
+ }\r
+ PrintToScrollback("Info: raw tag bits = %s", bits);\r
+\r
+ TagType = (shift3>>8)&0xff;\r
+ if ( TagType != ((shift0>>16)&0xff) ) {\r
+ PrintToScrollback("Error: start and stop bits do not match!");\r
+ return;\r
+ }\r
+ else if (TagType == 0x7e) {\r
+ PrintToScrollback("Info: Readonly TI tag detected.");\r
+ return;\r
+ }\r
+ else if (TagType == 0xfe) {\r
+ PrintToScrollback("Info: Rewriteable TI tag detected.");\r
+\r
+ // put 64 bit data into shift1 and shift0\r
+ shift0 = (shift0>>24) | (shift1 << 8);\r
+ shift1 = (shift1>>24) | (shift2 << 8);\r
+\r
+ // align 16 bit crc into lower half of shift2\r
+ shift2 = ((shift2>>24) | (shift3 << 8)) & 0x0ffff;\r
+\r
+ // align 16 bit "end bits" or "ident" into lower half of shift3\r
+ shift3 >>= 16;\r
+\r
+ // only 15 bits compare, last bit of ident is not valid\r
+ if ( (shift3^shift0)&0x7fff ) {\r
+ PrintToScrollback("Error: Ident mismatch!");\r
+ }\r
+ // WARNING the order of the bytes in which we calc crc below needs checking\r
+ // i'm 99% sure the crc algorithm is correct, but it may need to eat the\r
+ // bytes in reverse or something\r
+ // calculate CRC\r
+ crc=0;\r
+ crc = update_crc16(crc, (shift0)&0xff);\r
+ crc = update_crc16(crc, (shift0>>8)&0xff);\r
+ crc = update_crc16(crc, (shift0>>16)&0xff);\r
+ crc = update_crc16(crc, (shift0>>24)&0xff);\r
+ crc = update_crc16(crc, (shift1)&0xff);\r
+ crc = update_crc16(crc, (shift1>>8)&0xff);\r
+ crc = update_crc16(crc, (shift1>>16)&0xff);\r
+ crc = update_crc16(crc, (shift1>>24)&0xff);\r
+ PrintToScrollback("Info: Tag data = %08X%08X", shift1, shift0);\r
+ if (crc != (shift2&0xffff)) {\r
+ PrintToScrollback("Error: CRC mismatch, calculated %04X, got ^04X", crc, shift2&0xffff);\r
+ } else {\r
+ PrintToScrollback("Info: CRC %04X is good", crc);\r
+ }\r
+ }\r
+ else {\r
+ PrintToScrollback("Unknown tag type.");\r
+ return;\r
+ }\r
+}\r
+\r
+static void CmdNorm(char *str)\r
+{\r
+ int i;\r
+ int max = INT_MIN, min = INT_MAX;\r
+ for(i = 10; i < GraphTraceLen; i++) {\r
+ if(GraphBuffer[i] > max) {\r
+ max = GraphBuffer[i];\r
+ }\r
+ if(GraphBuffer[i] < min) {\r
+ min = GraphBuffer[i];\r
+ }\r
+ }\r
+ if(max != min) {\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ GraphBuffer[i] = (GraphBuffer[i] - ((max + min)/2))*1000/\r
+ (max - min);\r
+ }\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdAmp(char *str)\r
+{\r
+ int i, rising, falling;\r
+ int max = INT_MIN, min = INT_MAX;\r
+ for(i = 10; i < GraphTraceLen; i++) {\r
+ if(GraphBuffer[i] > max) {\r
+ max = GraphBuffer[i];\r
+ }\r
+ if(GraphBuffer[i] < min) {\r
+ min = GraphBuffer[i];\r
+ }\r
+ }\r
+ if(max != min) {\r
+ rising= falling= 0;\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ if(GraphBuffer[i+1] < GraphBuffer[i]) {\r
+ if(rising) {\r
+ GraphBuffer[i]= max;\r
+ rising= 0;\r
+ }\r
+ falling= 1;\r
+ }\r
+ if(GraphBuffer[i+1] > GraphBuffer[i]) {\r
+ if(falling) {\r
+ GraphBuffer[i]= min;\r
+ falling= 0;\r
+ }\r
+ rising= 1;\r
+ }\r
+ }\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdDec(char *str)\r
+{\r
+ int i;\r
+ for(i = 0; i < (GraphTraceLen/2); i++) {\r
+ GraphBuffer[i] = GraphBuffer[i*2];\r
+ }\r
+ GraphTraceLen /= 2;\r
+ PrintToScrollback("decimated by 2");\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdHpf(char *str)\r
+{\r
+ int i;\r
+ int accum = 0;\r
+ for(i = 10; i < GraphTraceLen; i++) {\r
+ accum += GraphBuffer[i];\r
+ }\r
+ accum /= (GraphTraceLen - 10);\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ GraphBuffer[i] -= accum;\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdZerocrossings(char *str)\r
+{\r
+ int i;\r
+ // Zero-crossings aren't meaningful unless the signal is zero-mean.\r
+ CmdHpf("");\r
+\r
+ int sign = 1;\r
+ int zc = 0;\r
+ int lastZc = 0;\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ if(GraphBuffer[i]*sign >= 0) {\r
+ // No change in sign, reproduce the previous sample count.\r
+ zc++;\r
+ GraphBuffer[i] = lastZc;\r
+ } else {\r
+ // Change in sign, reset the sample count.\r
+ sign = -sign;\r
+ GraphBuffer[i] = lastZc;\r
+ if(sign > 0) {\r
+ lastZc = zc;\r
+ zc = 0;\r
+ }\r
+ }\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdThreshold(char *str)\r
+{\r
+ int i;\r
+ int threshold = atoi(str);\r
+\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ if(GraphBuffer[i]>= threshold)\r
+ GraphBuffer[i]=1;\r
+ else\r
+ GraphBuffer[i]=-1;\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdLtrim(char *str)\r
+{\r
+ int i;\r
+ int ds = atoi(str);\r
+\r
+ for(i = ds; i < GraphTraceLen; i++) {\r
+ GraphBuffer[i-ds] = GraphBuffer[i];\r
+ }\r
+ GraphTraceLen -= ds;\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdAutoCorr(char *str)\r
+{\r
+ static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];\r
+\r
+ int window = atoi(str);\r
+\r
+ if(window == 0) {\r
+ PrintToScrollback("needs a window");\r
+ return;\r
+ }\r
+\r
+ if(window >= GraphTraceLen) {\r
+ PrintToScrollback("window must be smaller than trace (%d samples)",\r
+ GraphTraceLen);\r
+ return;\r
+ }\r
+\r
+ PrintToScrollback("performing %d correlations", GraphTraceLen - window);\r
+\r
+ int i;\r
+ for(i = 0; i < GraphTraceLen - window; i++) {\r
+ int sum = 0;\r
+ int j;\r
+ for(j = 0; j < window; j++) {\r
+ sum += (GraphBuffer[j]*GraphBuffer[i+j]) / 256;\r
+ }\r
+ CorrelBuffer[i] = sum;\r
+ }\r
+ GraphTraceLen = GraphTraceLen - window;\r
+ memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen*sizeof(int));\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdVchdemod(char *str)\r
+{\r
+ // Is this the entire sync pattern, or does this also include some\r
+ // data bits that happen to be the same everywhere? That would be\r
+ // lovely to know.\r
+ static const int SyncPattern[] = {\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+ 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
+ };\r
+\r
+ // So first, we correlate for the sync pattern, and mark that.\r
+ int bestCorrel = 0, bestPos = 0;\r
+ int i;\r
+ // It does us no good to find the sync pattern, with fewer than\r
+ // 2048 samples after it...\r
+ for(i = 0; i < (GraphTraceLen-2048); i++) {\r
+ int sum = 0;\r
+ int j;\r
+ for(j = 0; j < arraylen(SyncPattern); j++) {\r
+ sum += GraphBuffer[i+j]*SyncPattern[j];\r
+ }\r
+ if(sum > bestCorrel) {\r
+ bestCorrel = sum;\r
+ bestPos = i;\r
+ }\r
+ }\r
+ PrintToScrollback("best sync at %d [metric %d]", bestPos, bestCorrel);\r
+\r
+ char bits[257];\r
+ bits[256] = '\0';\r
+\r
+ int worst = INT_MAX;\r
+ int worstPos;\r
+\r
+ for(i = 0; i < 2048; i += 8) {\r
+ int sum = 0;\r
+ int j;\r
+ for(j = 0; j < 8; j++) {\r
+ sum += GraphBuffer[bestPos+i+j];\r
+ }\r
+ if(sum < 0) {\r
+ bits[i/8] = '.';\r
+ } else {\r
+ bits[i/8] = '1';\r
+ }\r
+ if(abs(sum) < worst) {\r
+ worst = abs(sum);\r
+ worstPos = i;\r
+ }\r
+ }\r
+ PrintToScrollback("bits:");\r
+ PrintToScrollback("%s", bits);\r
+ PrintToScrollback("worst metric: %d at pos %d", worst, worstPos);\r
+\r
+ if(strcmp(str, "clone")==0) {\r
+ GraphTraceLen = 0;\r
+ char *s;\r
+ for(s = bits; *s; s++) {\r
+ int j;\r
+ for(j = 0; j < 16; j++) {\r
+ GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0;\r
+ }\r
+ }\r
+ RepaintGraphWindow();\r
+ }\r
+}\r
+\r
+static void CmdIndalademod(char *str)\r
+{\r
+ // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID\r
+\r
+ int state = -1;\r
+ int count = 0;\r
+ int i, j;\r
+ // worst case with GraphTraceLen=64000 is < 4096\r
+ // under normal conditions it's < 2048\r
+ BYTE rawbits[4096];\r
+ int rawbit = 0;\r
+ int worst = 0, worstPos = 0;\r
+ PrintToScrollback("Expecting a bit less than %d raw bits", GraphTraceLen/32);\r
+ for(i = 0; i < GraphTraceLen-1; i += 2) {\r
+ count+=1;\r
+ if((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) {\r
+ if (state == 0) {\r
+ for(j = 0; j < count - 8; j += 16) {\r
+ rawbits[rawbit++] = 0;\r
+ }\r
+ if ((abs(count - j)) > worst) {\r
+ worst = abs(count - j);\r
+ worstPos = i;\r
+ }\r
+ }\r
+ state = 1;\r
+ count=0;\r
+ } else if((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) {\r
+ if (state == 1) {\r
+ for(j = 0; j < count - 8; j += 16) {\r
+ rawbits[rawbit++] = 1;\r
+ }\r
+ if ((abs(count - j)) > worst) {\r
+ worst = abs(count - j);\r
+ worstPos = i;\r
+ }\r
+ }\r
+ state = 0;\r
+ count=0;\r
+ }\r
+ }\r
+ PrintToScrollback("Recovered %d raw bits", rawbit);\r
+ PrintToScrollback("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos);\r
+\r
+ // Finding the start of a UID\r
+ int uidlen, long_wait;\r
+ if(strcmp(str, "224") == 0) {\r
+ uidlen=224;\r
+ long_wait=30;\r
+ } else {\r
+ uidlen=64;\r
+ long_wait=29;\r
+ }\r
+ int start;\r
+ int first = 0;\r
+ for(start = 0; start <= rawbit - uidlen; start++) {\r
+ first = rawbits[start];\r
+ for(i = start; i < start + long_wait; i++) {\r
+ if(rawbits[i] != first) {\r
+ break;\r
+ }\r
+ }\r
+ if(i == (start + long_wait)) {\r
+ break;\r
+ }\r
+ }\r
+ if(start == rawbit - uidlen + 1) {\r
+ PrintToScrollback("nothing to wait for");\r
+ return;\r
+ }\r
+\r
+ // Inverting signal if needed\r
+ if(first == 1) {\r
+ for(i = start; i < rawbit; i++) {\r
+ rawbits[i] = !rawbits[i];\r
+ }\r
+ }\r
+\r
+ // Dumping UID\r
+ BYTE bits[224];\r
+ char showbits[225];\r
+ showbits[uidlen]='\0';\r
+ int bit;\r
+ i = start;\r
+ int times = 0;\r
+ if(uidlen > rawbit) {\r
+ PrintToScrollback("Warning: not enough raw bits to get a full UID");\r
+ for(bit = 0; bit < rawbit; bit++) {\r
+ bits[bit] = rawbits[i++];\r
+ // As we cannot know the parity, let's use "." and "/"\r
+ showbits[bit] = '.' + bits[bit];\r
+ }\r
+ showbits[bit+1]='\0';\r
+ PrintToScrollback("Partial UID=%s", showbits);\r
+ return;\r
+ } else {\r
+ for(bit = 0; bit < uidlen; bit++) {\r
+ bits[bit] = rawbits[i++];\r
+ showbits[bit] = '0' + bits[bit];\r
+ }\r
+ times = 1;\r
+ }\r
+ PrintToScrollback("UID=%s", showbits);\r
+\r
+ // Checking UID against next occurences\r
+ for(; i + uidlen <= rawbit;) {\r
+ int failed = 0;\r
+ for(bit = 0; bit < uidlen; bit++) {\r
+ if(bits[bit] != rawbits[i++]) {\r
+ failed = 1;\r
+ break;\r
+ }\r
+ }\r
+ if (failed == 1) {\r
+ break;\r
+ }\r
+ times += 1;\r
+ }\r
+ PrintToScrollback("Occurences: %d (expected %d)", times, (rawbit - start) / uidlen);\r
+\r
+ // Remodulating for tag cloning\r
+ GraphTraceLen = 32*uidlen;\r
+ i = 0;\r
+ int phase = 0;\r
+ for(bit = 0; bit < uidlen; bit++) {\r
+ if(bits[bit] == 0) {\r
+ phase = 0;\r
+ } else {\r
+ phase = 1;\r
+ }\r
+ int j;\r
+ for(j = 0; j < 32; j++) {\r
+ GraphBuffer[i++] = phase;\r
+ phase = !phase;\r
+ }\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdFlexdemod(char *str)\r
+{\r
+ int i;\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ if(GraphBuffer[i] < 0) {\r
+ GraphBuffer[i] = -1;\r
+ } else {\r
+ GraphBuffer[i] = 1;\r
+ }\r
+ }\r
+\r
+#define LONG_WAIT 100\r
+ int start;\r
+ for(start = 0; start < GraphTraceLen - LONG_WAIT; start++) {\r
+ int first = GraphBuffer[start];\r
+ for(i = start; i < start + LONG_WAIT; i++) {\r
+ if(GraphBuffer[i] != first) {\r
+ break;\r
+ }\r
+ }\r
+ if(i == (start + LONG_WAIT)) {\r
+ break;\r
+ }\r
+ }\r
+ if(start == GraphTraceLen - LONG_WAIT) {\r
+ PrintToScrollback("nothing to wait for");\r
+ return;\r
+ }\r
+\r
+ GraphBuffer[start] = 2;\r
+ GraphBuffer[start+1] = -2;\r
+\r
+ BYTE bits[64];\r
+\r
+ int bit;\r
+ i = start;\r
+ for(bit = 0; bit < 64; bit++) {\r
+ int j;\r
+ int sum = 0;\r
+ for(j = 0; j < 16; j++) {\r
+ sum += GraphBuffer[i++];\r
+ }\r
+ if(sum > 0) {\r
+ bits[bit] = 1;\r
+ } else {\r
+ bits[bit] = 0;\r
+ }\r
+ PrintToScrollback("bit %d sum %d", bit, sum);\r
+ }\r
+\r
+ for(bit = 0; bit < 64; bit++) {\r
+ int j;\r
+ int sum = 0;\r
+ for(j = 0; j < 16; j++) {\r
+ sum += GraphBuffer[i++];\r
+ }\r
+ if(sum > 0 && bits[bit] != 1) {\r
+ PrintToScrollback("oops1 at %d", bit);\r
+ }\r
+ if(sum < 0 && bits[bit] != 0) {\r
+ PrintToScrollback("oops2 at %d", bit);\r
+ }\r
+ }\r
+\r
+ GraphTraceLen = 32*64;\r
+ i = 0;\r
+ int phase = 0;\r
+ for(bit = 0; bit < 64; bit++) {\r
+ if(bits[bit] == 0) {\r
+ phase = 0;\r
+ } else {\r
+ phase = 1;\r
+ }\r
+ int j;\r
+ for(j = 0; j < 32; j++) {\r
+ GraphBuffer[i++] = phase;\r
+ phase = !phase;\r
+ }\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/*\r
+ * Generic command to demodulate ASK.\r
+ *\r
+ * Argument is convention: positive or negative (High mod means zero\r
+ * or high mod means one)\r
+ *\r
+ * Updates the Graph trace with 0/1 values\r
+ *\r
+ * Arguments:\r
+ * c : 0 or 1\r
+ */\r
+\r
+static void Cmdaskdemod(char *str) {\r
+ int i;\r
+ int c, high = 0, low = 0;\r
+\r
+ // TODO: complain if we do not give 2 arguments here !\r
+ // (AL - this doesn't make sense! we're only using one argument!!!)\r
+ sscanf(str, "%i", &c);\r
+\r
+ /* Detect high and lows and clock */\r
+ // (AL - clock???)\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+ if(c != 0 && c != 1) {\r
+ PrintToScrollback("Invalid argument: %s",str);\r
+ return;\r
+ }\r
+\r
+ if (GraphBuffer[0] > 0) {\r
+ GraphBuffer[0] = 1-c;\r
+ } else {\r
+ GraphBuffer[0] = c;\r
+ }\r
+ for(i=1;i<GraphTraceLen;i++) {\r
+ /* Transitions are detected at each peak\r
+ * Transitions are either:\r
+ * - we're low: transition if we hit a high\r
+ * - we're high: transition if we hit a low\r
+ * (we need to do it this way because some tags keep high or\r
+ * low for long periods, others just reach the peak and go\r
+ * down)\r
+ */\r
+ if ((GraphBuffer[i]==high) && (GraphBuffer[i-1] == c)) {\r
+ GraphBuffer[i]=1-c;\r
+ } else if ((GraphBuffer[i]==low) && (GraphBuffer[i-1] == (1-c))){\r
+ GraphBuffer[i] = c;\r
+ } else {\r
+ /* No transition */\r
+ GraphBuffer[i] = GraphBuffer[i-1];\r
+ }\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/* Print our clock rate */\r
+static void Cmddetectclockrate(char *str)\r
+{\r
+ int clock = detectclock(0);\r
+ PrintToScrollback("Auto-detected clock rate: %d", clock);\r
+}\r
+\r
+/*\r
+ * Detect clock rate\r
+ */\r
+int detectclock(int peak)\r
+{\r
+ int i;\r
+ int clock = 0xFFFF;\r
+ int lastpeak = 0;\r
+\r
+ /* Detect peak if we don't have one */\r
+ if (!peak)\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ if (GraphBuffer[i] > peak)\r
+ peak = GraphBuffer[i];\r
+\r
+ for (i = 1; i < GraphTraceLen; i++)\r
+ {\r
+ /* If this is the beginning of a peak */\r
+ if (GraphBuffer[i-1] != GraphBuffer[i] && GraphBuffer[i] == peak)\r
+ {\r
+ /* Find lowest difference between peaks */\r
+ if (lastpeak && i - lastpeak < clock)\r
+ {\r
+ clock = i - lastpeak;\r
+ }\r
+ lastpeak = i;\r
+ }\r
+ }\r
+\r
+ return clock;\r
+}\r
+\r
+/* Get or auto-detect clock rate */\r
+int GetClock(char *str, int peak)\r
+{\r
+ int clock;\r
+\r
+ sscanf(str, "%i", &clock);\r
+ if (!strcmp(str, ""))\r
+ clock = 0;\r
+\r
+ /* Auto-detect clock */\r
+ if (!clock)\r
+ {\r
+ clock = detectclock(peak);\r
+\r
+ /* Only print this message if we're not looping something */\r
+ if (!go)\r
+ PrintToScrollback("Auto-detected clock rate: %d", clock);\r
+ }\r
+\r
+ return clock;\r
+}\r
+\r
+/*\r
+ * Convert to a bitstream\r
+ */\r
+static void Cmdbitstream(char *str) {\r
+ int i, j;\r
+ int bit;\r
+ int gtl;\r
+ int clock;\r
+ int low = 0;\r
+ int high = 0;\r
+ int hithigh, hitlow, first;\r
+\r
+ /* Detect high and lows and clock */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+\r
+ /* Get our clock */\r
+ clock = GetClock(str, high);\r
+\r
+ gtl = CmdClearGraph(0);\r
+\r
+ bit = 0;\r
+ for (i = 0; i < (int)(gtl / clock); i++)\r
+ {\r
+ hithigh = 0;\r
+ hitlow = 0;\r
+ first = 1;\r
+\r
+ /* Find out if we hit both high and low peaks */\r
+ for (j = 0; j < clock; j++)\r
+ {\r
+ if (GraphBuffer[(i * clock) + j] == high)\r
+ hithigh = 1;\r
+ else if (GraphBuffer[(i * clock) + j] == low)\r
+ hitlow = 1;\r
+\r
+ /* it doesn't count if it's the first part of our read\r
+ because it's really just trailing from the last sequence */\r
+ if (first && (hithigh || hitlow))\r
+ hithigh = hitlow = 0;\r
+ else\r
+ first = 0;\r
+\r
+ if (hithigh && hitlow)\r
+ break;\r
+ }\r
+\r
+ /* If we didn't hit both high and low peaks, we had a bit transition */\r
+ if (!hithigh || !hitlow)\r
+ bit ^= 1;\r
+\r
+ CmdAppendGraph(0, clock, bit);\r
+// for (j = 0; j < (int)(clock/2); j++)\r
+// GraphBuffer[(i * clock) + j] = bit ^ 1;\r
+// for (j = (int)(clock/2); j < clock; j++)\r
+// GraphBuffer[(i * clock) + j] = bit;\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/* Modulate our data into manchester */\r
+static void Cmdmanchestermod(char *str)\r
+{\r
+ int i, j;\r
+ int clock;\r
+ int bit, lastbit, wave;\r
+\r
+ /* Get our clock */\r
+ clock = GetClock(str, 0);\r
+\r
+ wave = 0;\r
+ lastbit = 1;\r
+ for (i = 0; i < (int)(GraphTraceLen / clock); i++)\r
+ {\r
+ bit = GraphBuffer[i * clock] ^ 1;\r
+\r
+ for (j = 0; j < (int)(clock/2); j++)\r
+ GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;\r
+ for (j = (int)(clock/2); j < clock; j++)\r
+ GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;\r
+\r
+ /* Keep track of how we start our wave and if we changed or not this time */\r
+ wave ^= bit ^ lastbit;\r
+ lastbit = bit;\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/*\r
+ * Manchester demodulate a bitstream. The bitstream needs to be already in\r
+ * the GraphBuffer as 0 and 1 values\r
+ *\r
+ * Give the clock rate as argument in order to help the sync - the algorithm\r
+ * resyncs at each pulse anyway.\r
+ *\r
+ * Not optimized by any means, this is the 1st time I'm writing this type of\r
+ * routine, feel free to improve...\r
+ *\r
+ * 1st argument: clock rate (as number of samples per clock rate)\r
+ * Typical values can be 64, 32, 128...\r
+ */\r
+static void Cmdmanchesterdemod(char *str) {\r
+ int i, j, invert= 0;\r
+ int bit;\r
+ int clock;\r
+ int lastval;\r
+ int low = 0;\r
+ int high = 0;\r
+ int hithigh, hitlow, first;\r
+ int lc = 0;\r
+ int bitidx = 0;\r
+ int bit2idx = 0;\r
+ int warnings = 0;\r
+\r
+ /* check if we're inverting output */\r
+ if(*str == 'i')\r
+ {\r
+ PrintToScrollback("Inverting output");\r
+ invert= 1;\r
+ do\r
+ ++str;\r
+ while(*str == ' '); // in case a 2nd argument was given\r
+ }\r
+\r
+ /* Holds the decoded bitstream: each clock period contains 2 bits */\r
+ /* later simplified to 1 bit after manchester decoding. */\r
+ /* Add 10 bits to allow for noisy / uncertain traces without aborting */\r
+ /* int BitStream[GraphTraceLen*2/clock+10]; */\r
+\r
+ /* But it does not work if compiling on WIndows: therefore we just allocate a */\r
+ /* large array */\r
+ int BitStream[MAX_GRAPH_TRACE_LEN];\r
+\r
+ /* Detect high and lows */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+\r
+ /* Get our clock */\r
+ clock = GetClock(str, high);\r
+\r
+ int tolerance = clock/4;\r
+\r
+ /* Detect first transition */\r
+ /* Lo-Hi (arbitrary) */\r
+ /* skip to the first high */\r
+ for (i= 0; i < GraphTraceLen; i++)\r
+ if(GraphBuffer[i] == high)\r
+ break;\r
+ /* now look for the first low */\r
+ for (; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] == low)\r
+ {\r
+ lastval = i;\r
+ break;\r
+ }\r
+ }\r
+\r
+ /* If we're not working with 1/0s, demod based off clock */\r
+ if (high != 1)\r
+ {\r
+ bit = 0; /* We assume the 1st bit is zero, it may not be\r
+ * the case: this routine (I think) has an init problem.\r
+ * Ed.\r
+ */\r
+ for (; i < (int)(GraphTraceLen / clock); i++)\r
+ {\r
+ hithigh = 0;\r
+ hitlow = 0;\r
+ first = 1;\r
+\r
+ /* Find out if we hit both high and low peaks */\r
+ for (j = 0; j < clock; j++)\r
+ {\r
+ if (GraphBuffer[(i * clock) + j] == high)\r
+ hithigh = 1;\r
+ else if (GraphBuffer[(i * clock) + j] == low)\r
+ hitlow = 1;\r
+\r
+ /* it doesn't count if it's the first part of our read\r
+ because it's really just trailing from the last sequence */\r
+ if (first && (hithigh || hitlow))\r
+ hithigh = hitlow = 0;\r
+ else\r
+ first = 0;\r
+\r
+ if (hithigh && hitlow)\r
+ break;\r
+ }\r
+\r
+ /* If we didn't hit both high and low peaks, we had a bit transition */\r
+ if (!hithigh || !hitlow)\r
+ bit ^= 1;\r
+\r
+ BitStream[bit2idx++] = bit ^ invert;\r
+ }\r
+ }\r
+\r
+ /* standard 1/0 bitstream */\r
+ else\r
+ {\r
+\r
+ /* Then detect duration between 2 successive transitions */\r
+ for (bitidx = 1; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i-1] != GraphBuffer[i])\r
+ {\r
+ lc = i-lastval;\r
+ lastval = i;\r
+\r
+ // Error check: if bitidx becomes too large, we do not\r
+ // have a Manchester encoded bitstream or the clock is really\r
+ // wrong!\r
+ if (bitidx > (GraphTraceLen*2/clock+8) ) {\r
+ PrintToScrollback("Error: the clock you gave is probably wrong, aborting.");\r
+ return;\r
+ }\r
+ // Then switch depending on lc length:\r
+ // Tolerance is 1/4 of clock rate (arbitrary)\r
+ if (abs(lc-clock/2) < tolerance) {\r
+ // Short pulse : either "1" or "0"\r
+ BitStream[bitidx++]=GraphBuffer[i-1];\r
+ } else if (abs(lc-clock) < tolerance) {\r
+ // Long pulse: either "11" or "00"\r
+ BitStream[bitidx++]=GraphBuffer[i-1];\r
+ BitStream[bitidx++]=GraphBuffer[i-1];\r
+ } else {\r
+ // Error\r
+ warnings++;\r
+ PrintToScrollback("Warning: Manchester decode error for pulse width detection.");\r
+ PrintToScrollback("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");\r
+\r
+ if (warnings > 100)\r
+ {\r
+ PrintToScrollback("Error: too many detection errors, aborting.");\r
+ return;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream\r
+ // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful\r
+ // to stop output at the final bitidx2 value, not bitidx\r
+ for (i = 0; i < bitidx; i += 2) {\r
+ if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {\r
+ BitStream[bit2idx++] = 1 ^ invert;\r
+ } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {\r
+ BitStream[bit2idx++] = 0 ^ invert;\r
+ } else {\r
+ // We cannot end up in this state, this means we are unsynchronized,\r
+ // move up 1 bit:\r
+ i++;\r
+ warnings++;\r
+ PrintToScrollback("Unsynchronized, resync...");\r
+ PrintToScrollback("(too many of those messages mean the stream is not Manchester encoded)");\r
+\r
+ if (warnings > 100)\r
+ {\r
+ PrintToScrollback("Error: too many decode errors, aborting.");\r
+ return;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ PrintToScrollback("Manchester decoded bitstream");\r
+ // Now output the bitstream to the scrollback by line of 16 bits\r
+ for (i = 0; i < (bit2idx-16); i+=16) {\r
+ PrintToScrollback("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",\r
+ BitStream[i],\r
+ BitStream[i+1],\r
+ BitStream[i+2],\r
+ BitStream[i+3],\r
+ BitStream[i+4],\r
+ BitStream[i+5],\r
+ BitStream[i+6],\r
+ BitStream[i+7],\r
+ BitStream[i+8],\r
+ BitStream[i+9],\r
+ BitStream[i+10],\r
+ BitStream[i+11],\r
+ BitStream[i+12],\r
+ BitStream[i+13],\r
+ BitStream[i+14],\r
+ BitStream[i+15]);\r
+ }\r
+}\r
+\r
+/*\r
+ * Usage ???\r
+ */\r
+static void CmdHiddemod(char *str)\r
+{\r
+ if(GraphTraceLen < 4800) {\r
+ PrintToScrollback("too short; need at least 4800 samples");\r
+ return;\r
+ }\r
+\r
+ GraphTraceLen = 4800;\r
+ int i;\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ if(GraphBuffer[i] < 0) {\r
+ GraphBuffer[i] = 0;\r
+ } else {\r
+ GraphBuffer[i] = 1;\r
+ }\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdPlot(char *str)\r
+{\r
+ ShowGraphWindow();\r
+}\r
+\r
+static void CmdGrid(char *str)\r
+{\r
+ sscanf(str, "%i %i", &PlotGridX, &PlotGridY);\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdHide(char *str)\r
+{\r
+ HideGraphWindow();\r
+}\r
+\r
+static void CmdScale(char *str)\r
+{\r
+ CursorScaleFactor = atoi(str);\r
+ if(CursorScaleFactor == 0) {\r
+ PrintToScrollback("bad, can't have zero scale");\r
+ CursorScaleFactor = 1;\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdSave(char *str)\r
+{\r
+ FILE *f = fopen(str, "w");\r
+ if(!f) {\r
+ PrintToScrollback("couldn't open '%s'", str);\r
+ return;\r
+ }\r
+ int i;\r
+ for(i = 0; i < GraphTraceLen; i++) {\r
+ fprintf(f, "%d\n", GraphBuffer[i]);\r
+ }\r
+ fclose(f);\r
+ PrintToScrollback("saved to '%s'", str);\r
+}\r
+\r
+static void CmdLoad(char *str)\r
+{\r
+ FILE *f = fopen(str, "r");\r
+ if(!f) {\r
+ PrintToScrollback("couldn't open '%s'", str);\r
+ return;\r
+ }\r
+\r
+ GraphTraceLen = 0;\r
+ char line[80];\r
+ while(fgets(line, sizeof(line), f)) {\r
+ GraphBuffer[GraphTraceLen] = atoi(line);\r
+ GraphTraceLen++;\r
+ }\r
+ fclose(f);\r
+ PrintToScrollback("loaded %d samples", GraphTraceLen);\r
+ RepaintGraphWindow();\r
+}\r
+\r
+static void CmdHIDsimTAG(char *str)\r
+{\r
+ unsigned int hi=0, lo=0;\r
+ int n=0, i=0;\r
+ UsbCommand c;\r
+\r
+ while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
+ hi=(hi<<4)|(lo>>28);\r
+ lo=(lo<<4)|(n&0xf);\r
+ }\r
+\r
+ PrintToScrollback("Emulating tag with ID %x%16x", hi, lo);\r
+\r
+ c.cmd = CMD_HID_SIM_TAG;\r
+ c.ext1 = hi;\r
+ c.ext2 = lo;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdReadmem(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_READ_MEM;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdVersion(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_VERSION;\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdLcdReset(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_LCD_RESET;\r
+ c.ext1 = atoi(str);\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+static void CmdLcd(char *str)\r
+{\r
+ int i, j;\r
+ UsbCommand c;\r
+ c.cmd = CMD_LCD;\r
+ sscanf(str, "%x %d", &i, &j);\r
+ while (j--) {\r
+ c.ext1 = i&0x1ff;\r
+ SendCommand(&c, FALSE);\r
+ }\r
+}\r
+\r
+/*\r
+ * Sets the divisor for LF frequency clock: lets the user choose any LF frequency below\r
+ * 600kHz.\r
+ */\r
+static void CmdSetDivisor(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SET_LF_DIVISOR;\r
+ c.ext1 = atoi(str);\r
+ if (( c.ext1<0) || (c.ext1>255)) {\r
+ PrintToScrollback("divisor must be between 19 and 255");\r
+ } else {\r
+ SendCommand(&c, FALSE);\r
+ PrintToScrollback("Divisor set, expected freq=%dHz", 12000000/(c.ext1+1));\r
+ }\r
+}\r
+\r
+static void CmdSetMux(char *str)\r
+{\r
+ UsbCommand c;\r
+ c.cmd = CMD_SET_ADC_MUX;\r
+ if(strcmp(str, "lopkd") == 0) {\r
+ c.ext1 = 0;\r
+ } else if(strcmp(str, "loraw") == 0) {\r
+ c.ext1 = 1;\r
+ } else if(strcmp(str, "hipkd") == 0) {\r
+ c.ext1 = 2;\r
+ } else if(strcmp(str, "hiraw") == 0) {\r
+ c.ext1 = 3;\r
+ }\r
+ SendCommand(&c, FALSE);\r
+}\r
+\r
+typedef void HandlerFunction(char *cmdline);\r
+\r
+/* in alphabetic order */\r
+static struct {\r
+ char *name;\r
+ HandlerFunction *handler;\r
+ int offline; // 1 if the command can be used when in offline mode\r
+ char *docString;\r
+} CommandTable[] = {\r
+ {"amp", CmdAmp, 1, "Amplify peaks"},\r
+ {"askdemod", Cmdaskdemod, 1, "<0|1> -- Attempt to demodulate simple ASK tags"},\r
+ {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},\r
+ {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},\r
+ {"bitstream", Cmdbitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},\r
+ {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},\r
+ {"dec", CmdDec, 1, "Decimate samples"},\r
+ {"detectclock", Cmddetectclockrate, 1, "Detect clock rate"},\r
+ {"detectreader", CmdDetectReader, 0, "['l'|'h'] -- Detect external reader field (option 'l' or 'h' to limit to LF or HF)"},\r
+ {"em410xsim", CmdEM410xsim, 1, "<UID> -- Simulate EM410x tag"},\r
+ {"em410xread", CmdEM410xread, 1, "[clock rate] -- Extract ID from EM410x tag"},\r
+ {"em410xwatch", CmdEM410xwatch, 0, "Watches for EM410x tags"},\r
+ {"em4x50read", CmdEM4x50read, 1, "Extract data from EM4x50 tag"},\r
+ {"exit", CmdQuit, 1, "Exit program"},\r
+ {"flexdemod", CmdFlexdemod, 1, "Demodulate samples for FlexPass"},\r
+ {"fpgaoff", CmdFPGAOff, 0, "Set FPGA off"},\r
+ {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},\r
+ {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},\r
+ {"hexsamples", CmdHexsamples, 0, "<blocks> -- Dump big buffer as hex bytes"},\r
+ {"hi14alist", CmdHi14alist, 0, "List ISO 14443a history"},\r
+ {"hi14areader", CmdHi14areader, 0, "Act like an ISO14443 Type A reader"},\r
+ {"hi14asim", CmdHi14asim, 0, "<UID> -- Fake ISO 14443a tag"},\r
+ {"hi14asnoop", CmdHi14asnoop, 0, "Eavesdrop ISO 14443 Type A"},\r
+ {"hi14bdemod", CmdHi14bdemod, 1, "Demodulate ISO14443 Type B from tag"},\r
+ {"hi14list", CmdHi14list, 0, "List ISO 14443 history"},\r
+ {"hi14read", CmdHi14read, 0, "Read HF tag (ISO 14443)"},\r
+ {"hi14sim", CmdHi14sim, 0, "Fake ISO 14443 tag"},\r
+ {"hi14snoop", CmdHi14snoop, 0, "Eavesdrop ISO 14443"},\r
+ {"hi15demod", CmdHi15demod, 1, "Demodulate ISO15693 from tag"},\r
+ {"hi15read", CmdHi15read, 0, "Read HF tag (ISO 15693)"},\r
+ {"hi15reader", CmdHi15reader, 0, "Act like an ISO15693 reader"},\r
+ {"hi15sim", CmdHi15tag, 0, "Fake an ISO15693 tag"},\r
+ {"hiddemod", CmdHiddemod, 1, "Demodulate HID Prox Card II (not optimal)"},\r
+ {"hide", CmdHide, 1, "Hide graph window"},\r
+ {"hidfskdemod", CmdHIDdemodFSK, 0, "Realtime HID FSK demodulator"},\r
+ {"hidsimtag", CmdHIDsimTAG, 0, "<ID> -- HID tag simulator"},\r
+ {"higet", CmdHi14read_sim, 0, "<samples> -- Get samples HF, 'analog'"},\r
+ {"hisamples", CmdHisamples, 0, "Get raw samples for HF tag"},\r
+ {"hisampless", CmdHisampless, 0, "<samples> -- Get signed raw samples, HF tag"},\r
+ {"hisamplest", CmdHi14readt, 0, "Get samples HF, for testing"},\r
+ {"hisimlisten", CmdHisimlisten, 0, "Get HF samples as fake tag"},\r
+ {"hpf", CmdHpf, 1, "Remove DC offset from trace"},\r
+ {"indalademod", CmdIndalademod, 0, "['224'] -- Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"},\r
+ {"lcd", CmdLcd, 0, "<HEX command> <count> -- Send command/data to LCD"},\r
+ {"lcdreset", CmdLcdReset, 0, "Hardware reset LCD"},\r
+ {"legicrfsim", CmdLegicRfSim, 0, "Start the LEGIC RF tag simulator"},\r
+ {"legicrfread", CmdLegicRfRead, 0, "Start the LEGIC RF reader"},\r
+ {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},\r
+ {"locomread", CmdLoCommandRead, 0, "<off period> <'0' period> <'1' period> <command> ['h'] -- Modulate LF reader field to send command before read (all periods in microseconds) (option 'h' for 134)"},\r
+ {"loread", CmdLoread, 0, "['h'] -- Read 125/134 kHz LF ID-only tag (option 'h' for 134)"},\r
+ {"losamples", CmdLosamples, 0, "[128 - 16000] -- Get raw samples for LF tag"},\r
+ {"losim", CmdLosim, 0, "Simulate LF tag"},\r
+ {"losimbidir", CmdLosimBidir, 0, "Simulate LF tag (with bidirectional data transmission between reader and tag)"},\r
+ {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},\r
+ {"mandemod", Cmdmanchesterdemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},\r
+ {"manmod", Cmdmanchestermod, 1, "[clock rate] -- Manchester modulate a binary stream"},\r
+ {"norm", CmdNorm, 1, "Normalize max/min to +/-500"},\r
+ {"plot", CmdPlot, 1, "Show graph window"},\r
+ {"quit", CmdQuit, 1, "Quit program"},\r
+ {"readmem", CmdReadmem, 0, "[address] -- Read memory at decimal address from flash"},\r
+ {"reset", CmdReset, 0, "Reset the Proxmark3"},\r
+ {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},\r
+ {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},\r
+ {"setlfdivisor", CmdSetDivisor, 0, "<19 - 255> -- Drive LF antenna at 12Mhz/(divisor+1)"},\r
+ {"setmux", CmdSetMux, 0, "<loraw|hiraw|lopkd|hipkd> -- Set the ADC mux to a specific value"},\r
+ {"sri512read", CmdSri512read, 0, "<int> -- Read contents of a SRI512 tag"},\r
+ {"srix4kread", CmdSrix4kread, 0, "<int> -- Read contents of a SRIX4K tag"},
+ {"tidemod", CmdTIDemod, 1, "Demodulate raw bits for TI-type LF tag"},\r
+ {"tiread", CmdTIRead, 0, "Read and decode a TI 134 kHz tag"},\r
+ {"tiwrite", CmdTIWrite, 0, "Write new data to a r/w TI 134 kHz tag"},\r
+ {"threshold", CmdThreshold, 1, "Maximize/minimize every value in the graph window depending on threshold"},\r
+ {"tune", CmdTune, 0, "Measure antenna tuning"},\r
+ {"vchdemod", CmdVchdemod, 0, "['clone'] -- Demodulate samples for VeriChip"},\r
+ {"version", CmdVersion, 0, "Show version inforation about the connected Proxmark"},\r
+ {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},\r
+};\r
+\r
+static struct {\r
+ char *name;\r
+ char *args;\r
+ char *argshelp;\r
+ char *description;\r
+ } CommandExtendedHelp[]= {\r
+ {"detectreader","'l'|'h'","'l' specifies LF antenna scan only, 'h' specifies HF antenna scan only.","Monitor antenna for changes in voltage. Output is in three fields: CHANGED, CURRENT, PERIOD,\nwhere CHANGED is the value just changed from, CURRENT is the current value and PERIOD is the\nnumber of program loops since the last change.\n\nThe RED LED indicates LF field detected, and the GREEN LED indicates HF field detected."},\r
+ {"tune","","","Drive LF antenna at all divisor range values (19 - 255) and store the results in the output\nbuffer. Issuing 'losamples' and then 'plot' commands will display the resulting peak. 12MHz\ndivided by the peak's position plus one gives the antenna's resonant frequency. For convenience,\nthis value is also printed out by the command."},\r
+ };\r
+\r
+//-----------------------------------------------------------------------------\r
+// Entry point into our code: called whenever the user types a command and\r
+// then presses Enter, which the full command line that they typed.\r
+//-----------------------------------------------------------------------------\r
+void CommandReceived(char *cmd)\r
+{\r
+ int i;\r
+ char line[256];\r
+\r
+ PrintToScrollback("> %s", cmd);\r
+\r
+ if(strcmp(cmd, "help") == 0 || strncmp(cmd,"help ",strlen("help ")) == 0) {\r
+ // check if we're doing extended help\r
+ if(strlen(cmd) > strlen("help ")) {\r
+ cmd += strlen("help ");\r
+ for(i = 0; i < sizeof(CommandExtendedHelp) / sizeof(CommandExtendedHelp[0]); i++) {\r
+ if(strcmp(CommandExtendedHelp[i].name,cmd) == 0) {\r
+ PrintToScrollback("\nExtended help for '%s':\n", cmd);\r
+ PrintToScrollback("Args: %s\t- %s\n",CommandExtendedHelp[i].args,CommandExtendedHelp[i].argshelp);\r
+ PrintToScrollback(CommandExtendedHelp[i].description);\r
+ PrintToScrollback("");\r
+ return;\r
+ }\r
+ }\r
+ PrintToScrollback("No extended help available for '%s'", cmd);\r
+ return;\r
+ }\r
+ if (offline) PrintToScrollback("Operating in OFFLINE mode (no device connected)");\r
+ PrintToScrollback("\r\nAvailable commands:");\r
+ for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
+ if (offline && (CommandTable[i].offline==0)) continue;\r
+ memset(line, ' ', sizeof(line));\r
+ strcpy(line+2, CommandTable[i].name);\r
+ line[strlen(line)] = ' ';\r
+ sprintf(line+15, " -- %s", CommandTable[i].docString);\r
+ PrintToScrollback("%s", line);\r
+ }\r
+ PrintToScrollback("");\r
+ PrintToScrollback("'help <command>' for extended help on that command\n");\r
+ return;\r
+ }\r
+\r
+ for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
+ char *name = CommandTable[i].name;\r
+ if(memcmp(cmd, name, strlen(name))==0 &&\r
+ (cmd[strlen(name)] == ' ' || cmd[strlen(name)] == '\0'))\r
+ {\r
+ cmd += strlen(name);\r
+ while(*cmd == ' ') {\r
+ cmd++;\r
+ }\r
+ if (offline && (CommandTable[i].offline==0)) {\r
+ PrintToScrollback("Offline mode, cannot use this command.");\r
+ return;\r
+ }\r
+ (CommandTable[i].handler)(cmd);\r
+ return;\r
+ }\r
+ }\r
+ PrintToScrollback(">> bad command '%s'", cmd);\r
+}\r
+\r
+//-----------------------------------------------------------------------------\r
+// Entry point into our code: called whenever we received a packet over USB\r
+// that we weren't necessarily expecting, for example a debug print.\r
+//-----------------------------------------------------------------------------\r
+void UsbCommandReceived(UsbCommand *c)\r
+{\r
+ switch(c->cmd) {\r
+ case CMD_DEBUG_PRINT_STRING: {\r
+ char s[100];\r
+ if(c->ext1 > 70 || c->ext1 < 0) {\r
+ c->ext1 = 0;\r
+ }\r
+ memcpy(s, c->d.asBytes, c->ext1);\r
+ s[c->ext1] = '\0';\r
+ PrintToScrollback("#db# %s", s);\r
+ break;\r
+ }\r
+\r
+ case CMD_DEBUG_PRINT_INTEGERS:\r
+ PrintToScrollback("#db# %08x, %08x, %08x\r\n", c->ext1, c->ext2, c->ext3);\r
+ break;\r
+\r
+ case CMD_MEASURED_ANTENNA_TUNING: {\r
+ int peakv, peakf;\r
+ int vLf125, vLf134, vHf;\r
+ vLf125 = c->ext1 & 0xffff;\r
+ vLf134 = c->ext1 >> 16;\r
+ vHf = c->ext2 & 0xffff;;\r
+ peakf = c->ext3 & 0xffff;\r
+ peakv = c->ext3 >> 16;\r
+ PrintToScrollback("");\r
+ PrintToScrollback("");\r
+ PrintToScrollback("# LF antenna: %5.2f V @ 125.00 kHz", vLf125/1000.0);\r
+ PrintToScrollback("# LF antenna: %5.2f V @ 134.00 kHz", vLf134/1000.0);\r
+ PrintToScrollback("# LF optimal: %5.2f V @%9.2f kHz", peakv/1000.0, 12000.0/(peakf+1));\r
+ PrintToScrollback("# HF antenna: %5.2f V @ 13.56 MHz", vHf/1000.0);\r
+ if (peakv<2000)\r
+ PrintToScrollback("# Your LF antenna is unusable.");\r
+ else if (peakv<10000)\r
+ PrintToScrollback("# Your LF antenna is marginal.");\r
+ if (vHf<2000)\r
+ PrintToScrollback("# Your HF antenna is unusable.");\r
+ else if (vHf<5000)\r
+ PrintToScrollback("# Your HF antenna is marginal.");\r
+ break;\r
+ }\r
+ default:\r
+ PrintToScrollback("unrecognized command %08x\n", c->cmd);\r
+ break;\r
+ }\r
+}\r
--- /dev/null
+#include <usb.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include "translate.h"
+#include "prox.h"
+#include "proxmark3.h"
+
+static DWORD ExpectedAddr;
+static BYTE QueuedToSend[256];
+static BOOL AllWritten;
+#define PHYSICAL_FLASH_START 0x100000
+
+struct partition {
+ int start;
+ int end;
+ int precious;
+ const char *name;
+};
+struct partition partitions[] = {
+ {0x100000, 0x102000, 1, "bootrom"},
+ {0x102000, 0x110000, 0, "fpga"},
+ {0x110000, 0x140000, 0, "os"},
+};
+
+/* If translate is set, subtract PHYSICAL_FLASH_START to translate for old
+ * bootroms.
+ */
+static void FlushPrevious(int translate)
+{
+ UsbCommand c;
+ memset(&c, 0, sizeof(c));
+
+ printf("expected = %08x flush, ", ExpectedAddr);
+
+ int i;
+ for(i = 0; i < 240; i += 48) {
+ c.cmd = CMD_SETUP_WRITE;
+ memcpy(c.d.asBytes, QueuedToSend+i, 48);
+ c.ext1 = (i/4);
+ SendCommand(&c, TRUE);
+ }
+
+ c.cmd = CMD_FINISH_WRITE;
+ c.ext1 = (ExpectedAddr-1) & (~255);
+ if(translate) {
+ c.ext1 -= PHYSICAL_FLASH_START;
+ }
+ printf("c.ext1 = %08x\r", c.ext1);
+ memcpy(c.d.asBytes, QueuedToSend+240, 16);
+ SendCommand(&c, TRUE);
+
+ AllWritten = TRUE;
+}
+
+/* Where must be between start_addr (inclusive) and end_addr (exclusive).
+ */
+static void GotByte(DWORD where, BYTE which, int start_addr, int end_addr, int translate)
+{
+ AllWritten = FALSE;
+
+ if(where < start_addr || where >= end_addr) {
+ printf("bad: got byte at %08x, outside of range %08x-%08x\n", where, start_addr, end_addr);
+ exit(-1);
+ }
+
+ if(where != ExpectedAddr) {
+ printf("bad: got at %08x, expected at %08x\n", where, ExpectedAddr);
+ exit(-1);
+ }
+ QueuedToSend[where & 255] = which;
+ ExpectedAddr++;
+
+ if((where & 255) == 255) {
+ // we have completed a full page
+ FlushPrevious(translate);
+ }
+}
+
+static int HexVal(int c)
+{
+ c = tolower(c);
+ if(c >= '0' && c <= '9') {
+ return c - '0';
+ } else if(c >= 'a' && c <= 'f') {
+ return (c - 'a') + 10;
+ } else {
+ printf("bad hex digit '%c'\n", c);
+ exit(-1);
+ }
+}
+
+static BYTE HexByte(char *s)
+{
+ return (HexVal(s[0]) << 4) | HexVal(s[1]);
+}
+
+static void LoadFlashFromSRecords(const char *file, int start_addr, int end_addr, int translate)
+{
+ ExpectedAddr = start_addr;
+
+ FILE *f = fopen(file, "r");
+ if(!f) {
+ printf("couldn't open file\n");
+ exit(-1);
+ }
+
+ char line[512];
+ while(fgets(line, sizeof(line), f)) {
+ if(memcmp(line, "S3", 2)==0) {
+ char *s = line + 2;
+ int len = HexByte(s) - 5;
+ s += 2;
+
+ char addrStr[9];
+ memcpy(addrStr, s, 8);
+ addrStr[8] = '\0';
+ DWORD addr;
+ sscanf(addrStr, "%x", &addr);
+ s += 8;
+
+ /* Accept files that are located at PHYSICAL_FLASH_START, and files that are located at 0 */
+ if(addr < PHYSICAL_FLASH_START)
+ addr += PHYSICAL_FLASH_START;
+
+ int i;
+ for(i = 0; i < len; i++) {
+ while((addr+i) > ExpectedAddr) {
+ GotByte(ExpectedAddr, 0xff, start_addr, end_addr, translate);
+ }
+ GotByte(addr+i, HexByte(s), start_addr, end_addr, translate);
+ s += 2;
+ }
+ }
+ }
+
+ if(!AllWritten) FlushPrevious(translate);
+
+ fclose(f);
+ printf("\ndone.\n");
+}
+
+static int PrepareFlash(struct partition *p, const char *filename, unsigned int state)
+{
+ int translate = 0;
+ if(state & DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH) {
+ UsbCommand c;
+ c.cmd = CMD_START_FLASH;
+ c.ext1 = p->start;
+ c.ext2 = p->end;
+
+ /* Only send magic when flashing bootrom */
+ if(p->precious) {
+ c.ext3 = START_FLASH_MAGIC;
+ } else {
+ c.ext3 = 0;
+ }
+ SendCommand(&c, TRUE);
+ translate = 0;
+ } else {
+ fprintf(stderr, "Warning: Your bootloader does not understand the new START_FLASH command\n");
+ fprintf(stderr, " It is recommended that you update your bootloader\n\n");
+ translate = 1;
+ }
+
+ LoadFlashFromSRecords(filename, p->start, p->end, translate);
+ return 1;
+}
+
+static unsigned int GetProxmarkState(void)
+{
+ unsigned int state = 0;
+
+ UsbCommand c;
+ c.cmd = CMD_DEVICE_INFO;
+ SendCommand(&c, FALSE);
+
+ UsbCommand resp;
+ ReceiveCommand(&resp);
+ /* Three cases:
+ * 1. The old bootrom code will ignore CMD_DEVICE_INFO, but respond with an ACK
+ * 2. The old os code will respond with CMD_DEBUG_PRINT_STRING and "unknown command"
+ * 3. The new bootrom and os codes will respond with CMD_DEVICE_INFO and flags
+ */
+
+ switch(resp.cmd) {
+ case CMD_ACK:
+ state = DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM;
+ break;
+ case CMD_DEBUG_PRINT_STRING:
+ state = DEVICE_INFO_FLAG_CURRENT_MODE_OS;
+ break;
+ case CMD_DEVICE_INFO:
+ state = resp.ext1;
+ break;
+ default:
+ fprintf(stderr, "Couldn't get proxmark state, bad response type: 0x%04X\n", resp.cmd);
+ exit(-1);
+ break;
+ }
+
+#if 0
+ if(state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) printf("New bootrom present\n");
+ if(state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) printf("New osimage present\n");
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) printf("Currently in bootrom\n");
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) printf("Currently in OS\n");
+#endif
+
+ return state;
+}
+
+static unsigned int EnterFlashState(void)
+{
+ unsigned int state = GetProxmarkState();
+
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) {
+ /* Already in flash state, we're done. */
+ return state;
+ }
+
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) {
+ fprintf(stderr,"Entering flash-mode...\n");
+ UsbCommand c;
+ bzero(&c, sizeof(c));
+
+ if( (state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) && (state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) ) {
+ /* New style handover: Send CMD_START_FLASH, which will reset the board and
+ * enter the bootrom on the next boot.
+ */
+ c.cmd = CMD_START_FLASH;
+ SendCommand(&c, FALSE);
+ fprintf(stderr,"(You don't have to do anything. Press and release the button only if you want to abort)\n");
+ fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");
+ } else {
+ /* Old style handover: Ask the user to press the button, then reset the board */
+ c.cmd = CMD_HARDWARE_RESET;
+ SendCommand(&c, FALSE);
+ fprintf(stderr,"(Press and hold down button NOW if your bootloader requires it)\n");
+ fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");
+ }
+
+ CloseProxmark();
+ sleep(1);
+
+ while(!(devh=OpenProxmark(0))) { sleep(1); }
+ fprintf(stderr,"Found.\n");
+
+ return GetProxmarkState();
+ }
+
+ return 0;
+}
+
+static void usage(char **argv)
+{
+ int i;
+ fprintf(stderr, "Usage: %s areas image [image [image]]\n", argv[0]);
+ fprintf(stderr, " areas is a comma-separated list of areas to flash, with no spaces\n");
+ fprintf(stderr, " Known areas are:");
+ for(i=0; i<(sizeof(partitions)/sizeof(partitions[0])); i++) {
+ fprintf(stderr, " %s", partitions[i].name);
+ }
+ fprintf(stderr, "\n");
+ fprintf(stderr, " image is the path to the corresponding image\n\n");
+ fprintf(stderr, "Example: %s os,fpga path/to/osimage.s19 path/to/fpgaimage.s19\n", argv[0]);
+}
+
+/* On first call, have *offset = -1, *length = 0; */
+static int find_next_area(const char *str, int *offset, int *length)
+{
+ if(*str == '\0') return 0;
+ if((*offset >= 0) && str[*offset + *length] == '\0') return 0;
+ *offset += 1 + *length;
+
+ char *next_comma = strchr(str + *offset, ',');
+ if(next_comma == NULL) {
+ *length = strlen(str) - *offset;
+ } else {
+ *length = next_comma-(str+*offset);
+ }
+ return 1;
+}
+
+int main(int argc, char **argv) {
+ if(argc < 2) {
+ usage(argv);
+ exit(-1);
+ }
+
+ /* Count area arguments */
+ int areas = 0, offset=-1, length=0;
+ while(find_next_area(argv[1], &offset, &length)) areas++;
+
+ if(areas != argc - 2) {
+ usage(argv);
+ exit(-1);
+ }
+
+ usb_init();
+
+ fprintf(stderr,"Waiting for Proxmark to appear on USB... ");
+ while(!(devh=OpenProxmark(0))) { sleep(1); }
+ fprintf(stderr,"Found.\n");
+
+ unsigned int state = EnterFlashState();
+
+ if( !(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) ) {
+ fprintf(stderr, "Proxmark would not enter flash state, abort\n");
+ exit(-1);
+ }
+
+ offset=-1; length=0;
+ int current_area = 0;
+ while(find_next_area(argv[1], &offset, &length)) {
+ int i;
+ struct partition *p = NULL;
+ for(i=0; i<sizeof(partitions)/sizeof(partitions[0]); i++) {
+ if(strncmp(partitions[i].name, argv[1] + offset, length) == 0) {
+ /* Check if the name matches the bootrom partition, and if so, require "bootrom" to
+ * be written in full. The other names may be abbreviated.
+ */
+ if(!partitions[i].precious || (strlen(partitions[i].name) == length)) {
+ p = &partitions[i];
+ }
+ break;
+ }
+ }
+
+ if(p == NULL) {
+ fprintf(stderr, "Warning: area name '");
+ fwrite(argv[1]+offset, length, 1, stderr);
+ fprintf(stderr, "' unknown, ignored\n");
+ } else {
+ fprintf(stderr, "Flashing %s from %s\n", p->name, argv[2+current_area]);
+ PrepareFlash(p, argv[2+current_area], state);
+ }
+ current_area++;
+ }
+
+ UsbCommand c;
+ bzero(&c, sizeof(c));
+ c.cmd = CMD_HARDWARE_RESET;
+ SendCommand(&c, FALSE);
+
+ CloseProxmark();
+
+ fprintf(stderr,"Have a nice day!\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdarg.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "proxgui.h"
+#include "translate.h"
+#include "prox.h"
+
+int GraphBuffer[MAX_GRAPH_TRACE_LEN];
+int GraphTraceLen;
+double CursorScaleFactor;
+int PlotGridX, PlotGridY;
+int CommandFinished;
+int offline;
+
+static char *logfilename = "proxmark3.log";
+
+void PrintToScrollback(char *fmt, ...) {
+ va_list argptr, argptr2;
+ static FILE *logfile = NULL;
+ static int logging=1;
+
+ if (logging && !logfile) {
+ logfile=fopen(logfilename, "a");
+ if (!logfile) {
+ fprintf(stderr, "Can't open logfile, logging disabled!\n");
+ logging=0;
+ }
+ }
+
+ va_start(argptr, fmt);
+ va_copy(argptr2, argptr);
+ vprintf(fmt, argptr);
+ va_end(argptr);
+ printf("\n");
+ if (logging && logfile) {
+#if 0
+ char zeit[25];
+ time_t jetzt_t;
+ struct tm *jetzt;
+
+ jetzt_t = time(NULL);
+ jetzt = localtime(&jetzt_t);
+ strftime(zeit, 25, "%b %e %T", jetzt);
+
+ fprintf(logfile,"%s ", zeit);
+#endif
+ vfprintf(logfile, fmt, argptr2);
+ fprintf(logfile,"\n");
+ fflush(logfile);
+ }
+ va_end(argptr2);
+}
+
+void setlogfilename(char *fn)
+{
+ logfilename = fn;
+}
--- /dev/null
+//-----------------------------------------------------------------------------\r
+// Routines for the user interface when doing interactive things with prox\r
+// cards; this is basically a command line thing, in one window, and then\r
+// another window to do the graphs.\r
+// Jonathan Westhues, Sept 2005\r
+//-----------------------------------------------------------------------------\r
+#include <windows.h>\r
+#include <limits.h>\r
+#include <commctrl.h>\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+#include <math.h>\r
+\r
+#include "prox.h"\r
+\r
+#define oops() do { \\r
+ char line[100]; \\r
+ sprintf(line, "Internal error at line %d file '%s'", __LINE__, \\r
+ __FILE__); \\r
+ MessageBox(NULL, line, "Error", MB_ICONERROR); \\r
+ exit(-1); \\r
+} while(0)\r
+\r
+void dbp(char *str, ...)\r
+{\r
+ va_list f;\r
+ char buf[1024];\r
+ va_start(f, str);\r
+ vsprintf(buf, str, f);\r
+ OutputDebugString(buf);\r
+ OutputDebugString("\n");\r
+}\r
+\r
+int GraphBuffer[MAX_GRAPH_TRACE_LEN];\r
+int GraphTraceLen;\r
+int PlotGridX, PlotGridY;\r
+\r
+HPEN GreyPenLite, GreyPen, GreenPen, WhitePen, YellowPen;\r
+HBRUSH GreenBrush, YellowBrush;\r
+\r
+static int GraphStart = 0;\r
+static double GraphPixelsPerPoint = 1;\r
+\r
+static int CursorAPos;\r
+static int CursorBPos;\r
+double CursorScaleFactor = 1.0;\r
+static HPEN CursorAPen;\r
+static HPEN CursorBPen;\r
+\r
+static HWND CommandWindow;\r
+static HWND GraphWindow;\r
+static HWND ScrollbackEdit;\r
+static HWND CommandEdit;\r
+\r
+#define COMMAND_HISTORY_MAX 16\r
+static char CommandHistory[COMMAND_HISTORY_MAX][256];\r
+static int CommandHistoryPos = -1;\r
+static int CommandHistoryNext;\r
+\r
+static HFONT MyFixedFont;\r
+#define FixedFont(x) SendMessage((x), WM_SETFONT, (WPARAM)MyFixedFont, TRUE)\r
+\r
+void ExecCmd(char *cmd)\r
+{\r
+}\r
+\r
+int CommandFinished;\r
+int offset = 64;\r
+\r
+static void ResizeCommandWindow(void)\r
+{\r
+ int w, h;\r
+ RECT r;\r
+ GetClientRect(CommandWindow, &r);\r
+ w = r.right - r.left;\r
+ h = r.bottom - r.top;\r
+ MoveWindow(ScrollbackEdit, 10, 10, w - 20, h - 50, TRUE);\r
+ MoveWindow(CommandEdit, 10, h - 29, w - 20, 22, TRUE);\r
+}\r
+\r
+void RepaintGraphWindow(void)\r
+{\r
+ InvalidateRect(GraphWindow, NULL, TRUE);\r
+}\r
+\r
+static LRESULT CALLBACK\r
+ CommandWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)\r
+{\r
+ switch (msg) {\r
+ case WM_DESTROY:\r
+ case WM_QUIT:\r
+ exit(0);\r
+ return 0;\r
+\r
+ case WM_SIZE:\r
+ ResizeCommandWindow();\r
+ return 0;\r
+\r
+ case WM_SETFOCUS:\r
+ SetFocus(CommandEdit);\r
+ break;\r
+\r
+ default:\r
+ return DefWindowProc(hwnd, msg, wParam, lParam);\r
+ }\r
+\r
+ return 1;\r
+}\r
+\r
+static void PaintGraph(HDC hdc)\r
+{\r
+ RECT r;\r
+ HBRUSH brush;\r
+ HPEN pen;\r
+ char str[250];\r
+ int yMin = INT_MAX;\r
+ int yMax = INT_MIN;\r
+ int yMean = 0;\r
+ int startMax = 0;\r
+ int absYMax = 1;\r
+ int n = 0, i = 0;\r
+\r
+ brush = GreenBrush;\r
+ pen = GreenPen;\r
+\r
+ GetClientRect(GraphWindow, &r);\r
+ int zeroHeight = (r.top + r.bottom) >> 1;\r
+\r
+ // plot X and Y grid lines\r
+ if ((PlotGridX > 0) && ((PlotGridX * GraphPixelsPerPoint) > 1)) {\r
+ for(i = offset; i < r.right; i += (int)(PlotGridX * GraphPixelsPerPoint)) {\r
+ SelectObject(hdc, GreyPenLite);\r
+ MoveToEx(hdc, r.left + i, r.top, NULL);\r
+ LineTo(hdc, r.left + i, r.bottom);\r
+ }\r
+ }\r
+\r
+ if ((PlotGridY > 0) && ((PlotGridY * GraphPixelsPerPoint) > 1)){\r
+ for(i = 0; i < ((r.top + r.bottom)>>1); i += (int)(PlotGridY * GraphPixelsPerPoint)) {\r
+ SelectObject(hdc, GreyPenLite);\r
+ MoveToEx(hdc, r.left, zeroHeight + i, NULL);\r
+ LineTo(hdc, r.right, zeroHeight + i);\r
+ MoveToEx(hdc, r.left, zeroHeight - i, NULL);\r
+ LineTo(hdc, r.right, zeroHeight - i);\r
+ }\r
+ }\r
+\r
+ // print vertical separator white line on the left of the window\r
+ SelectObject(hdc, WhitePen);\r
+ MoveToEx(hdc, r.left + offset, r.top, NULL);\r
+ LineTo(hdc, r.left + offset, r.bottom);\r
+\r
+ // print horizontal grey zero axis line\r
+ SelectObject(hdc, GreyPen);\r
+ MoveToEx(hdc, r.left, zeroHeight, NULL);\r
+ LineTo(hdc, r.right, zeroHeight);\r
+\r
+ startMax = (GraphTraceLen - (int)((r.right - r.left - offset) / GraphPixelsPerPoint));\r
+ // check boundaries\r
+ if(startMax < 0) startMax = 0;\r
+ if(GraphStart > startMax) GraphStart = startMax;\r
+ if(GraphStart < 0) GraphStart = 0;\r
+\r
+\r
+ SelectObject(hdc, pen);\r
+\r
+ // go over the portion of the graph to be displayed and find the largest\r
+ // absolute value which will be used to auto scale the graph when displayed\r
+ for(i = GraphStart; ; i++) {\r
+ if(i >= GraphTraceLen) {\r
+ break;\r
+ }\r
+ if(fabs((double)GraphBuffer[i]) > absYMax) {\r
+ absYMax = (int)fabs((double)GraphBuffer[i]);\r
+ }\r
+ int x = offset + (int)((i - GraphStart)*GraphPixelsPerPoint);\r
+ if(x > r.right) {\r
+ break;\r
+ }\r
+ }\r
+\r
+ absYMax = (int)(absYMax*1.2 + 1);\r
+ SelectObject(hdc, MyFixedFont);\r
+ SetTextColor(hdc, RGB(255, 255, 255));\r
+ SetBkColor(hdc, RGB(0, 0, 0));\r
+\r
+ // number of points that will be plotted\r
+ double span = (int)((r.right - r.left) / GraphPixelsPerPoint);\r
+\r
+ // one label every offset pixels, let us say\r
+ int labels = (r.right - r.left - offset) / offset;\r
+ if(labels <= 0) labels = 1;\r
+ // round to nearest power of 2\r
+ int pointsPerLabel = (int)(log(span / labels)/log(2.0));\r
+ if(pointsPerLabel <= 0) pointsPerLabel = 1;\r
+ pointsPerLabel = (int)pow(2.0,pointsPerLabel);\r
+\r
+ // go over the graph and plot samples and labels\r
+ for(i = GraphStart; ; i++) {\r
+ if(i >= GraphTraceLen) {\r
+ break;\r
+ }\r
+ int x = offset + (int)((i - GraphStart)*GraphPixelsPerPoint);\r
+ if(x > r.right + GraphPixelsPerPoint) {\r
+ break;\r
+ }\r
+\r
+ int y = GraphBuffer[i];\r
+ if(y < yMin) yMin = y;\r
+ if(y > yMax) yMax = y;\r
+ yMean += y;\r
+ n++;\r
+\r
+ y = (y * (r.top - r.bottom) / (2*absYMax)) + zeroHeight;\r
+ if(i == GraphStart) {\r
+ MoveToEx(hdc, x, y, NULL);\r
+ } else {\r
+ LineTo(hdc, x, y);\r
+ }\r
+\r
+ if(GraphPixelsPerPoint > 10) {\r
+ RECT f;\r
+ f.left = x - 3;\r
+ f.top = y - 3;\r
+ f.right = x + 3;\r
+ f.bottom = y + 3;\r
+ FillRect(hdc, &f, brush);\r
+ }\r
+\r
+ // plot labels\r
+ if(((i - GraphStart) % pointsPerLabel == 0) && i != GraphStart) {\r
+ SelectObject(hdc, WhitePen);\r
+ MoveToEx(hdc, x, zeroHeight - 8, NULL);\r
+ LineTo(hdc, x, zeroHeight + 8);\r
+\r
+ sprintf(str, "+%d", i);\r
+ SIZE size;\r
+ GetTextExtentPoint32(hdc, str, strlen(str), &size);\r
+ TextOut(hdc, x - size.cx, zeroHeight + 8, str, strlen(str));\r
+\r
+ SelectObject(hdc, pen);\r
+ MoveToEx(hdc, x, y, NULL);\r
+ }\r
+\r
+ // plot measurement cursors\r
+ if(i == CursorAPos || i == CursorBPos) {\r
+ if(i == CursorAPos) {\r
+ SelectObject(hdc, CursorAPen);\r
+ } else {\r
+ SelectObject(hdc, CursorBPen);\r
+ }\r
+ MoveToEx(hdc, x, r.top, NULL);\r
+ LineTo(hdc, x, r.bottom);\r
+\r
+ SelectObject(hdc, pen);\r
+ MoveToEx(hdc, x, y, NULL);\r
+ }\r
+ }\r
+\r
+ if(n != 0) {\r
+ yMean /= n;\r
+ }\r
+\r
+ // print misc information at bottom of graph window\r
+ sprintf(str, "@%d max=%d min=%d mean=%d n=%d/%d dt=%d [%.3f] zoom=%.3f CursorA=%d [%d] CursorB=%d [%d]",\r
+ GraphStart, yMax, yMin, yMean, n, GraphTraceLen,\r
+ CursorBPos - CursorAPos, (CursorBPos - CursorAPos)/CursorScaleFactor, GraphPixelsPerPoint,\r
+ CursorAPos, GraphBuffer[CursorAPos], CursorBPos, GraphBuffer[CursorBPos]);\r
+ TextOut(hdc, 50, r.bottom - 20, str, strlen(str));\r
+}\r
+\r
+static LRESULT CALLBACK\r
+ GraphWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)\r
+{\r
+ switch (msg) {\r
+ case WM_DESTROY:\r
+ case WM_QUIT:\r
+ GraphWindow = NULL;\r
+ return DefWindowProc(hwnd, msg, wParam, lParam);\r
+\r
+ case WM_SIZE:\r
+ RepaintGraphWindow();\r
+ return 0;\r
+\r
+ case WM_PAINT: {\r
+ PAINTSTRUCT ps;\r
+ HDC hdc = BeginPaint(hwnd, &ps);\r
+ if(GraphStart < 0) {\r
+ GraphStart = 0;\r
+ }\r
+ // This draws the trace.\r
+ PaintGraph(hdc);\r
+ EndPaint(hwnd, &ps);\r
+ break;\r
+ }\r
+ case WM_KEYDOWN:\r
+ switch(wParam) {\r
+ case VK_DOWN:\r
+ if(GraphPixelsPerPoint <= 8) {\r
+ GraphPixelsPerPoint *= 2;\r
+ }\r
+ break;\r
+\r
+ case VK_UP:\r
+ if(GraphPixelsPerPoint >= 0.01) {\r
+ GraphPixelsPerPoint /= 2;\r
+ }\r
+ break;\r
+\r
+ case VK_RIGHT:\r
+ if(GraphPixelsPerPoint < 16) {\r
+ GraphStart += (int)(16 / GraphPixelsPerPoint);\r
+ } else {\r
+ GraphStart++;\r
+ }\r
+ break;\r
+\r
+ case VK_LEFT:\r
+ if(GraphPixelsPerPoint < 16) {\r
+ GraphStart -= (int)(16 / GraphPixelsPerPoint);\r
+ } else {\r
+ GraphStart--;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ goto nopaint;\r
+ }\r
+ RepaintGraphWindow();\r
+nopaint:\r
+ break;\r
+\r
+ case WM_LBUTTONDOWN:\r
+ case WM_RBUTTONDOWN: {\r
+ int x = LOWORD(lParam);\r
+ x -= offset;\r
+ x = (int)(x / GraphPixelsPerPoint);\r
+ x += GraphStart;\r
+\r
+ if(msg == WM_LBUTTONDOWN) {\r
+ CursorAPos = x;\r
+ } else {\r
+ CursorBPos = x;\r
+ }\r
+ RepaintGraphWindow();\r
+ break;\r
+ }\r
+ default:\r
+ return DefWindowProc(hwnd, msg, wParam, lParam);\r
+ }\r
+\r
+ return 1;\r
+}\r
+\r
+void PrintToScrollback(char *fmt, ...)\r
+{\r
+ va_list f;\r
+ char str[1024];\r
+ strcpy(str, "\r\n");\r
+ va_start(f, fmt);\r
+ vsprintf(str+2, fmt, f);\r
+\r
+ static char TextBuf[1024*32];\r
+ SendMessage(ScrollbackEdit, WM_GETTEXT, (WPARAM)sizeof(TextBuf),\r
+ (LPARAM)TextBuf);\r
+\r
+ if(strlen(TextBuf) + strlen(str) + 1 <= sizeof(TextBuf)) {\r
+ strcat(TextBuf, str);\r
+ } else {\r
+ lstrcpyn(TextBuf, str, sizeof(TextBuf));\r
+ }\r
+\r
+ SendMessage(ScrollbackEdit, WM_SETTEXT, 0, (LPARAM)TextBuf);\r
+ SendMessage(ScrollbackEdit, EM_LINESCROLL, 0, (LPARAM)INT_MAX);\r
+}\r
+\r
+void ShowGraphWindow(void)\r
+{\r
+ if(GraphWindow) return;\r
+\r
+ GraphWindow = CreateWindowEx(0, "Graph", "graphed",\r
+ WS_OVERLAPPED | WS_BORDER | WS_MINIMIZEBOX | WS_SYSMENU |\r
+ WS_SIZEBOX | WS_VISIBLE, 200, 150, 600, 500, NULL, NULL, NULL,\r
+ NULL);\r
+ if(!GraphWindow) oops();\r
+}\r
+\r
+void HideGraphWindow(void)\r
+{\r
+ if(GraphWindow) {\r
+ DestroyWindow(GraphWindow);\r
+ GraphWindow = NULL;\r
+ }\r
+}\r
+\r
+static void SetCommandEditTo(char *str)\r
+{\r
+ SendMessage(CommandEdit, WM_SETTEXT, 0, (LPARAM)str);\r
+ SendMessage(CommandEdit, EM_SETSEL, strlen(str), strlen(str));\r
+}\r
+\r
+void ShowGui()\r
+{\r
+ WNDCLASSEX wc;\r
+ memset(&wc, 0, sizeof(wc));\r
+ wc.cbSize = sizeof(wc);\r
+\r
+ wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC;\r
+ wc.lpfnWndProc = (WNDPROC)CommandWindowProc;\r
+ wc.hInstance = NULL;\r
+ wc.hbrBackground = (HBRUSH)(COLOR_BTNSHADOW);\r
+ wc.lpszClassName = "Command";\r
+ wc.lpszMenuName = NULL;\r
+ wc.hCursor = LoadCursor(NULL, IDC_ARROW);\r
+\r
+ if(!RegisterClassEx(&wc)) oops();\r
+\r
+ wc.lpszClassName = "Graph";\r
+ wc.lpfnWndProc = (WNDPROC)GraphWindowProc;\r
+ wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);\r
+\r
+ if(!RegisterClassEx(&wc)) oops();\r
+\r
+ CommandWindow = CreateWindowEx(0, "Command", "prox",\r
+ WS_OVERLAPPED | WS_BORDER | WS_MINIMIZEBOX | WS_SYSMENU |\r
+ WS_SIZEBOX | WS_VISIBLE, 20, 20, 500, 400, NULL, NULL, NULL,\r
+ NULL);\r
+ if(!CommandWindow) oops();\r
+\r
+ ScrollbackEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "edit", "",\r
+ WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | ES_MULTILINE |\r
+ ES_AUTOVSCROLL | WS_VSCROLL, 0, 0, 0, 0, CommandWindow, NULL,\r
+ NULL, NULL);\r
+\r
+ CommandEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "edit", "",\r
+ WS_CHILD | WS_CLIPSIBLINGS | WS_TABSTOP | WS_VISIBLE |\r
+ ES_AUTOHSCROLL, 0, 0, 0, 0, CommandWindow, NULL, NULL, NULL);\r
+\r
+ MyFixedFont = CreateFont(14, 0, 0, 0, FW_REGULAR, FALSE, FALSE, FALSE,\r
+ ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,\r
+ FF_DONTCARE, "Lucida Console");\r
+ if(!MyFixedFont)\r
+ MyFixedFont = (HFONT)GetStockObject(SYSTEM_FONT);\r
+\r
+ FixedFont(ScrollbackEdit);\r
+ FixedFont(CommandEdit);\r
+\r
+ ResizeCommandWindow();\r
+ SetFocus(CommandEdit);\r
+\r
+ PrintToScrollback(">> Started prox, built " __DATE__ " " __TIME__);\r
+ PrintToScrollback(">> Connected to device");\r
+\r
+ GreyPenLite = CreatePen(PS_SOLID, 1, RGB(50, 50, 50));\r
+ GreyPen = CreatePen(PS_SOLID, 1, RGB(100, 100, 100));\r
+ GreenPen = CreatePen(PS_SOLID, 1, RGB(100, 255, 100));\r
+ YellowPen = CreatePen(PS_SOLID, 1, RGB(255, 255, 0));\r
+ GreenBrush = CreateSolidBrush(RGB(100, 255, 100));\r
+ YellowBrush = CreateSolidBrush(RGB(255, 255, 0));\r
+ WhitePen = CreatePen(PS_SOLID, 1, RGB(255, 255, 255));\r
+\r
+ CursorAPen = CreatePen(PS_DASH, 1, RGB(255, 255, 0));\r
+ CursorBPen = CreatePen(PS_DASH, 1, RGB(255, 0, 255));\r
+\r
+ MSG msg;\r
+ for(;;) {\r
+ if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {\r
+ if(msg.message == WM_KEYDOWN && msg.wParam == VK_RETURN) {\r
+ char got[1024];\r
+ SendMessage(CommandEdit, WM_GETTEXT, (WPARAM)sizeof(got),\r
+ (LPARAM)got);\r
+\r
+ if(strcmp(got, "cls")==0) {\r
+ SendMessage(ScrollbackEdit, WM_SETTEXT, 0, (LPARAM)"");\r
+ } else {\r
+ CommandReceived(got);\r
+ }\r
+ SendMessage(CommandEdit, WM_SETTEXT, 0, (LPARAM)"");\r
+\r
+ // Insert it into the command history, unless it is\r
+ // identical to the previous command in the history.\r
+ int prev = CommandHistoryNext - 1;\r
+ if(prev < 0) prev += COMMAND_HISTORY_MAX;\r
+ if(strcmp(CommandHistory[prev], got) != 0) {\r
+ strcpy(CommandHistory[CommandHistoryNext], got);\r
+ CommandHistoryNext++;\r
+ if(CommandHistoryNext == COMMAND_HISTORY_MAX) {\r
+ CommandHistoryNext = 0;\r
+ }\r
+ }\r
+ CommandHistoryPos = -1;\r
+ } else if(msg.message == WM_KEYDOWN && msg.wParam == VK_UP &&\r
+ msg.hwnd == CommandEdit)\r
+ {\r
+ if(CommandHistoryPos == -1) {\r
+ CommandHistoryPos = CommandHistoryNext;\r
+ }\r
+ CommandHistoryPos--;\r
+ if(CommandHistoryPos < 0) {\r
+ CommandHistoryPos = COMMAND_HISTORY_MAX-1;\r
+ }\r
+ SetCommandEditTo(CommandHistory[CommandHistoryPos]);\r
+ } else if(msg.message == WM_KEYDOWN && msg.wParam == VK_DOWN &&\r
+ msg.hwnd == CommandEdit)\r
+ {\r
+ CommandHistoryPos++;\r
+ if(CommandHistoryPos >= COMMAND_HISTORY_MAX) {\r
+ CommandHistoryPos = 0;\r
+ }\r
+ SetCommandEditTo(CommandHistory[CommandHistoryPos]);\r
+ } else if(msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE &&\r
+ msg.hwnd == CommandEdit)\r
+ {\r
+ SendMessage(CommandEdit, WM_SETTEXT, 0, (LPARAM)"");\r
+ } else {\r
+ if(msg.message == WM_KEYDOWN) {\r
+ CommandHistoryPos = -1;\r
+ }\r
+ TranslateMessage(&msg);\r
+ DispatchMessage(&msg);\r
+ }\r
+ }\r
+\r
+ if (!offline)\r
+ {\r
+ UsbCommand c;\r
+ if(ReceiveCommandPoll(&c))\r
+ UsbCommandReceived(&c);\r
+ }\r
+\r
+ Sleep(10);\r
+ }\r
+}\r
--- /dev/null
+#include <stdio.h>
+
+void ShowGraphWindow(void)
+{
+ static int warned = 0;
+
+ if (!warned) {
+ printf("No GUI in this build!\n");
+ warned = 1;
+ }
+}
+
+void HideGraphWindow(void) {}
+void RepaintGraphWindow(void) {}
+void MainGraphics() {}
+void InitGraphics(int argc, char **argv) {}
+void ExitGraphics(void) {}
--- /dev/null
+/*++\r
+\r
+Copyright (c) 1996-1998 Microsoft Corporation\r
+\r
+Module Name:\r
+\r
+ HIDPI.H\r
+\r
+Abstract:\r
+\r
+ Public Interface to the HID parsing library.\r
+\r
+Environment:\r
+\r
+ Kernel & user mode\r
+\r
+--*/\r
+\r
+#ifndef __HIDPI_H__\r
+#define __HIDPI_H__\r
+\r
+#include <pshpack4.h>\r
+\r
+// Please include "hidsdi.h" to use the user space (dll / parser)\r
+// Please include "hidpddi.h" to use the kernel space parser\r
+\r
+//\r
+// Special Link collection values for using the query functions\r
+//\r
+// Root collection references the collection at the base of the link\r
+// collection tree.\r
+// Unspecifies, references all collections in the link collection tree.\r
+//\r
+#define HIDP_LINK_COLLECTION_ROOT ((USHORT) -1)\r
+#define HIDP_LINK_COLLECTION_UNSPECIFIED ((USHORT) 0)\r
+\r
+\r
+typedef enum _HIDP_REPORT_TYPE\r
+{\r
+ HidP_Input,\r
+ HidP_Output,\r
+ HidP_Feature\r
+} HIDP_REPORT_TYPE;\r
+\r
+typedef struct _USAGE_AND_PAGE\r
+{\r
+ USAGE Usage;\r
+ USAGE UsagePage;\r
+} USAGE_AND_PAGE, *PUSAGE_AND_PAGE;\r
+\r
+#define HidP_IsSameUsageAndPage(u1, u2) ((* (PULONG) &u1) == (* (PULONG) &u2))\r
+\r
+typedef struct _HIDP_BUTTON_CAPS\r
+{\r
+ USAGE UsagePage;\r
+ UCHAR ReportID;\r
+ BOOLEAN IsAlias;\r
+\r
+ USHORT BitField;\r
+ USHORT LinkCollection; // A unique internal index pointer\r
+\r
+ USAGE LinkUsage;\r
+ USAGE LinkUsagePage;\r
+\r
+ BOOLEAN IsRange;\r
+ BOOLEAN IsStringRange;\r
+ BOOLEAN IsDesignatorRange;\r
+ BOOLEAN IsAbsolute;\r
+\r
+ ULONG Reserved[10];\r
+ union {\r
+ struct {\r
+ USAGE UsageMin, UsageMax;\r
+ USHORT StringMin, StringMax;\r
+ USHORT DesignatorMin, DesignatorMax;\r
+ USHORT DataIndexMin, DataIndexMax;\r
+ } Range;\r
+ struct {\r
+ USAGE Usage, Reserved1;\r
+ USHORT StringIndex, Reserved2;\r
+ USHORT DesignatorIndex, Reserved3;\r
+ USHORT DataIndex, Reserved4;\r
+ } NotRange;\r
+ };\r
+\r
+} HIDP_BUTTON_CAPS, *PHIDP_BUTTON_CAPS;\r
+\r
+\r
+typedef struct _HIDP_VALUE_CAPS\r
+{\r
+ USAGE UsagePage;\r
+ UCHAR ReportID;\r
+ BOOLEAN IsAlias;\r
+\r
+ USHORT BitField;\r
+ USHORT LinkCollection; // A unique internal index pointer\r
+\r
+ USAGE LinkUsage;\r
+ USAGE LinkUsagePage;\r
+\r
+ BOOLEAN IsRange;\r
+ BOOLEAN IsStringRange;\r
+ BOOLEAN IsDesignatorRange;\r
+ BOOLEAN IsAbsolute;\r
+\r
+ BOOLEAN HasNull; // Does this channel have a null report union\r
+ UCHAR Reserved;\r
+ USHORT BitSize; // How many bits are devoted to this value?\r
+\r
+ USHORT ReportCount; // See Note below. Usually set to 1.\r
+ USHORT Reserved2[5];\r
+\r
+ ULONG UnitsExp;\r
+ ULONG Units;\r
+\r
+ LONG LogicalMin, LogicalMax;\r
+ LONG PhysicalMin, PhysicalMax;\r
+\r
+ union {\r
+ struct {\r
+ USAGE UsageMin, UsageMax;\r
+ USHORT StringMin, StringMax;\r
+ USHORT DesignatorMin, DesignatorMax;\r
+ USHORT DataIndexMin, DataIndexMax;\r
+ } Range;\r
+\r
+ struct {\r
+ USAGE Usage, Reserved1;\r
+ USHORT StringIndex, Reserved2;\r
+ USHORT DesignatorIndex, Reserved3;\r
+ USHORT DataIndex, Reserved4;\r
+ } NotRange;\r
+ };\r
+} HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;\r
+\r
+//\r
+// Notes:\r
+//\r
+// ReportCount: When a report descriptor declares an Input, Output, or\r
+// Feature main item with fewer usage declarations than the report count, then\r
+// the last usage applies to all remaining unspecified count in that main item.\r
+// (As an example you might have data that required many fields to describe,\r
+// possibly buffered bytes.) In this case, only one value cap structure is\r
+// allocated for these associtated fields, all with the same usage, and Report\r
+// Count reflects the number of fields involved. Normally ReportCount is 1.\r
+// To access all of the fields in such a value structure would require using\r
+// HidP_GetUsageValueArray and HidP_SetUsageValueArray. HidP_GetUsageValue/\r
+// HidP_SetScaledUsageValue will also work, however, these functions will only\r
+// work with the first field of the structure.\r
+//\r
+\r
+//\r
+// The link collection tree consists of an array of LINK_COLLECTION_NODES\r
+// where the index into this array is the same as the collection number.\r
+//\r
+// Given a collection A which contains a subcollection B, A is defined to be\r
+// the parent B, and B is defined to be the child.\r
+//\r
+// Given collections A, B, and C where B and C are children of A, and B was\r
+// encountered before C in the report descriptor, B is defined as a sibling of\r
+// C. (This implies, of course, that if B is a sibling of C, then C is NOT a\r
+// sibling of B).\r
+//\r
+// B is defined as the NextSibling of C if and only if there exists NO\r
+// child collection of A, call it D, such that B is a sibling of D and D\r
+// is a sibling of C.\r
+//\r
+// E is defined to be the FirstChild of A if and only if for all children of A,\r
+// F, that are not equivalent to E, F is a sibling of E.\r
+// (This implies, of course, that the does not exist a child of A, call it G,\r
+// where E is a sibling of G). In other words the first sibling is the last\r
+// link collection found in the list.\r
+//\r
+// In other words, if a collection B is defined within the definition of another\r
+// collection A, B becomes a child of A. All collections with the same parent\r
+// are considered siblings. The FirstChild of the parent collection, A, will be\r
+// last collection defined that has A as a parent. The order of sibling pointers\r
+// is similarly determined. When a collection B is defined, it becomes the\r
+// FirstChild of it's parent collection. The previously defined FirstChild of the\r
+// parent collection becomes the NextSibling of the new collection. As new\r
+// collections with the same parent are discovered, the chain of sibling is built.\r
+//\r
+// With that in mind, the following describes conclusively a data structure\r
+// that provides direct traversal up, down, and accross the link collection\r
+// tree.\r
+//\r
+//\r
+typedef struct _HIDP_LINK_COLLECTION_NODE\r
+{\r
+ USAGE LinkUsage;\r
+ USAGE LinkUsagePage;\r
+ USHORT Parent;\r
+ USHORT NumberOfChildren;\r
+ USHORT NextSibling;\r
+ USHORT FirstChild;\r
+ ULONG CollectionType: 8; // As defined in 6.2.2.6 of HID spec\r
+ ULONG IsAlias : 1; // This link node is an allias of the next link node.\r
+ ULONG Reserved: 23;\r
+ PVOID UserContext; // The user can hang his coat here.\r
+} HIDP_LINK_COLLECTION_NODE, *PHIDP_LINK_COLLECTION_NODE;\r
+\r
+//\r
+// When a link collection is described by a delimiter, alias link collection\r
+// nodes are created. (One for each usage within the delimiter).\r
+// The parser assigns each capability description listed above only one\r
+// link collection.\r
+//\r
+// If a control is defined within a collection defined by\r
+// delimited usages, then that control is said to be within multiple link\r
+// collections, one for each usage within the open and close delimiter tokens.\r
+// Such multiple link collecions are said to be aliases. The first N-1 such\r
+// collections, listed in the link collection node array, have their IsAlias\r
+// bit set. The last such link collection is the link collection index used\r
+// in the capabilities described above.\r
+// Clients wishing to set a control in an aliased collection, should walk the\r
+// collection array once for each time they see the IsAlias flag set, and use\r
+// the last link collection as the index for the below accessor functions.\r
+//\r
+// NB: if IsAlias is set, then NextSibling should be one more than the current\r
+// link collection node index.\r
+//\r
+\r
+typedef PUCHAR PHIDP_REPORT_DESCRIPTOR;\r
+typedef struct _HIDP_PREPARSED_DATA * PHIDP_PREPARSED_DATA;\r
+\r
+typedef struct _HIDP_CAPS\r
+{\r
+ USAGE Usage;\r
+ USAGE UsagePage;\r
+ USHORT InputReportByteLength;\r
+ USHORT OutputReportByteLength;\r
+ USHORT FeatureReportByteLength;\r
+ USHORT Reserved[17];\r
+\r
+ USHORT NumberLinkCollectionNodes;\r
+\r
+ USHORT NumberInputButtonCaps;\r
+ USHORT NumberInputValueCaps;\r
+ USHORT NumberInputDataIndices;\r
+\r
+ USHORT NumberOutputButtonCaps;\r
+ USHORT NumberOutputValueCaps;\r
+ USHORT NumberOutputDataIndices;\r
+\r
+ USHORT NumberFeatureButtonCaps;\r
+ USHORT NumberFeatureValueCaps;\r
+ USHORT NumberFeatureDataIndices;\r
+} HIDP_CAPS, *PHIDP_CAPS;\r
+\r
+typedef struct _HIDP_DATA\r
+{\r
+ USHORT DataIndex;\r
+ USHORT Reserved;\r
+ union {\r
+ ULONG RawValue; // for values\r
+ BOOLEAN On; // for buttons MUST BE TRUE for buttons.\r
+ };\r
+} HIDP_DATA, *PHIDP_DATA;\r
+//\r
+// The HIDP_DATA structure is used with HidP_GetData and HidP_SetData\r
+// functions.\r
+//\r
+// The parser contiguously assigns every control (button or value) in a hid\r
+// device a unique data index from zero to NumberXXXDataIndices -1 , inclusive.\r
+// This value is found in the HIDP_BUTTON_CAPS and HIDP_VALUE_CAPS structures.\r
+//\r
+// Most clients will find the Get/Set Buttons / Value accessor functions\r
+// sufficient to their needs, as they will allow the clients to access the\r
+// data known to them while ignoring the other controls.\r
+//\r
+// More complex clients, which actually read the Button / Value Caps, and which\r
+// do a value add service to these routines (EG Direct Input), will need to\r
+// access all the data in the device without interest in the individual usage\r
+// or link collection location. These are the clients that will find\r
+// HidP_Data useful.\r
+//\r
+\r
+typedef struct _HIDP_UNKNOWN_TOKEN\r
+{\r
+ UCHAR Token;\r
+ UCHAR Reserved[3];\r
+ ULONG BitField;\r
+} HIDP_UNKNOWN_TOKEN, *PHIDP_UNKNOWN_TOKEN;\r
+\r
+typedef struct _HIDP_EXTENDED_ATTRIBUTES\r
+{\r
+ UCHAR NumGlobalUnknowns;\r
+ UCHAR Reserved [3];\r
+ PHIDP_UNKNOWN_TOKEN GlobalUnknowns;\r
+ // ... Additional attributes\r
+ ULONG Data [1]; // variableLength DO NOT ACCESS THIS FIELD\r
+} HIDP_EXTENDED_ATTRIBUTES, *PHIDP_EXTENDED_ATTRIBUTES;\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetCaps (\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ OUT PHIDP_CAPS Capabilities\r
+ );\r
+/*++\r
+Routine Description:\r
+ Returns a list of capabilities of a given hid device as described by its\r
+ preparsed data.\r
+\r
+Arguments:\r
+ PreparsedData The preparsed data returned from HIDCLASS.\r
+ Capabilities a HIDP_CAPS structure\r
+\r
+Return Value:\r
+· HIDP_STATUS_SUCCESS\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetLinkCollectionNodes (\r
+ OUT PHIDP_LINK_COLLECTION_NODE LinkCollectionNodes,\r
+ IN OUT PULONG LinkCollectionNodesLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+ );\r
+/*++\r
+Routine Description:\r
+ Return a list of PHIDP_LINK_COLLECTION_NODEs used to describe the link\r
+ collection tree of this hid device. See the above description of\r
+ struct _HIDP_LINK_COLLECTION_NODE.\r
+\r
+Arguments:\r
+ LinkCollectionNodes - a caller allocated array into which\r
+ HidP_GetLinkCollectionNodes will store the information\r
+\r
+ LinKCollectionNodesLength - the caller sets this value to the length of the\r
+ the array in terms of number of elements.\r
+ HidP_GetLinkCollectionNodes sets this value to the actual\r
+ number of elements set. The total number of nodes required to\r
+ describe this HID device can be found in the\r
+ NumberLinkCollectionNodes field in the HIDP_CAPS structure.\r
+\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetButtonCaps (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ OUT PHIDP_BUTTON_CAPS ButtonCaps,\r
+ IN OUT PUSHORT ButtonCapsLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+);\r
+#define HidP_GetButtonCaps(_Type_, _Caps_, _Len_, _Data_) \\r
+ HidP_GetSpecificButtonCaps (_Type_, 0, 0, 0, _Caps_, _Len_, _Data_)\r
+NTSTATUS __stdcall\r
+HidP_GetSpecificButtonCaps (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage, // Optional (0 => ignore)\r
+ IN USHORT LinkCollection, // Optional (0 => ignore)\r
+ IN USAGE Usage, // Optional (0 => ignore)\r
+ OUT PHIDP_BUTTON_CAPS ButtonCaps,\r
+ IN OUT PUSHORT ButtonCapsLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+ );\r
+/*++\r
+Description:\r
+ HidP_GetButtonCaps returns all the buttons (binary values) that are a part\r
+ of the given report type for the Hid device represented by the given\r
+ preparsed data.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
+\r
+ UsagePage A usage page value used to limit the button caps returned to\r
+ those on a given usage page. If set to 0, this parameter is\r
+ ignored. Can be used with LinkCollection and Usage parameters\r
+ to further limit the number of button caps structures returned.\r
+\r
+ LinkCollection HIDP_LINK_COLLECTION node array index used to limit the\r
+ button caps returned to those buttons in a given link\r
+ collection. If set to 0, this parameter is\r
+ ignored. Can be used with UsagePage and Usage parameters\r
+ to further limit the number of button caps structures\r
+ returned.\r
+\r
+ Usage A usage value used to limit the button caps returned to those\r
+ with the specified usage value. If set to 0, this parameter\r
+ is ignored. Can be used with LinkCollection and UsagePage\r
+ parameters to further limit the number of button caps\r
+ structures returned.\r
+\r
+ ButtonCaps A _HIDP_BUTTON_CAPS array containing information about all the\r
+ binary values in the given report. This buffer is provided by\r
+ the caller.\r
+\r
+ ButtonLength As input, this parameter specifies the length of the\r
+ ButtonCaps parameter (array) in number of array elements.\r
+ As output, this value is set to indicate how many of those\r
+ array elements were filled in by the function. The maximum number of\r
+ button caps that can be returned is found in the HIDP_CAPS\r
+ structure. If HIDP_STATUS_BUFFER_TOO_SMALL is returned,\r
+ this value contains the number of array elements needed to\r
+ successfully complete the request.\r
+\r
+ PreparsedData The preparsed data returned from HIDCLASS.\r
+\r
+\r
+Return Value\r
+HidP_GetSpecificButtonCaps returns the following error codes:\r
+· HIDP_STATUS_SUCCESS.\r
+· HIDP_STATUS_INVALID_REPORT_TYPE\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA\r
+· HIDP_STATUS_BUFFER_TOO_SMALL (all given entries however have been filled in)\r
+· HIDP_STATUS_USAGE_NOT_FOUND\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetValueCaps (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ OUT PHIDP_VALUE_CAPS ValueCaps,\r
+ IN OUT PUSHORT ValueCapsLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+);\r
+#define HidP_GetValueCaps(_Type_, _Caps_, _Len_, _Data_) \\r
+ HidP_GetSpecificValueCaps (_Type_, 0, 0, 0, _Caps_, _Len_, _Data_)\r
+NTSTATUS __stdcall\r
+HidP_GetSpecificValueCaps (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage, // Optional (0 => ignore)\r
+ IN USHORT LinkCollection, // Optional (0 => ignore)\r
+ IN USAGE Usage, // Optional (0 => ignore)\r
+ OUT PHIDP_VALUE_CAPS ValueCaps,\r
+ IN OUT PUSHORT ValueCapsLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+ );\r
+/*++\r
+Description:\r
+ HidP_GetValueCaps returns all the values (non-binary) that are a part\r
+ of the given report type for the Hid device represented by the given\r
+ preparsed data.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
+\r
+ UsagePage A usage page value used to limit the value caps returned to\r
+ those on a given usage page. If set to 0, this parameter is\r
+ ignored. Can be used with LinkCollection and Usage parameters\r
+ to further limit the number of value caps structures returned.\r
+\r
+ LinkCollection HIDP_LINK_COLLECTION node array index used to limit the\r
+ value caps returned to those buttons in a given link\r
+ collection. If set to 0, this parameter is\r
+ ignored. Can be used with UsagePage and Usage parameters\r
+ to further limit the number of value caps structures\r
+ returned.\r
+\r
+ Usage A usage value used to limit the value caps returned to those\r
+ with the specified usage value. If set to 0, this parameter\r
+ is ignored. Can be used with LinkCollection and UsagePage\r
+ parameters to further limit the number of value caps\r
+ structures returned.\r
+\r
+ ValueCaps A _HIDP_VALUE_CAPS array containing information about all the\r
+ non-binary values in the given report. This buffer is provided\r
+ by the caller.\r
+\r
+ ValueLength As input, this parameter specifies the length of the ValueCaps\r
+ parameter (array) in number of array elements. As output,\r
+ this value is set to indicate how many of those array elements\r
+ were filled in by the function. The maximum number of\r
+ value caps that can be returned is found in the HIDP_CAPS\r
+ structure. If HIDP_STATUS_BUFFER_TOO_SMALL is returned,\r
+ this value contains the number of array elements needed to\r
+ successfully complete the request.\r
+\r
+ PreparsedData The preparsed data returned from HIDCLASS.\r
+\r
+\r
+Return Value\r
+HidP_GetValueCaps returns the following error codes:\r
+· HIDP_STATUS_SUCCESS.\r
+· HIDP_STATUS_INVALID_REPORT_TYPE\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA\r
+· HIDP_STATUS_BUFFER_TOO_SMALL (all given entries however have been filled in)\r
+· HIDP_STATUS_USAGE_NOT_FOUND\r
+\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetExtendedAttributes (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USHORT DataIndex,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ OUT PHIDP_EXTENDED_ATTRIBUTES Attributes,\r
+ IN OUT PULONG LengthAttributes\r
+ );\r
+/*++\r
+Description:\r
+ Given a data index from the value or button capabilities of a given control\r
+ return any extended attributes for the control if any exist.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
+\r
+ DataIndex The data index for the given control, found in the capabilities\r
+ structure for that control\r
+\r
+ PreparsedData The preparsed data returned from HIDCLASS.\r
+\r
+ Attributes Pointer to a buffer into which the extended attribute data will\r
+ be copied.\r
+\r
+ LengthAttributes Length of the given buffer in bytes.\r
+\r
+Return Value\r
+ HIDP_STATUS_SUCCESS\r
+ HIDP_STATUS_DATA_INDEX_NOT_FOUND\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_InitializeReportForID (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN UCHAR ReportID,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN OUT PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Initialize a report based on the given report ID.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
+\r
+ PreparasedData Preparsed data structure returned by HIDCLASS\r
+\r
+ Report Buffer which to set the data into.\r
+\r
+ ReportLength Length of Report...Report should be at least as long as the\r
+ value indicated in the HIDP_CAPS structure for the device and\r
+ the corresponding ReportType\r
+\r
+Return Value\r
+\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal\r
+ to the length specified in HIDP_CAPS\r
+ structure for the given ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_SetData (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN PHIDP_DATA DataList,\r
+ IN OUT PULONG DataLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN OUT PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Please Note: Since usage value arrays deal with multiple fields for\r
+ for one usage value, they cannot be used with HidP_SetData\r
+ and HidP_GetData. In this case,\r
+ HIDP_STATUS_IS_USAGE_VALUE_ARRAY will be returned.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
+\r
+ DataList Array of HIDP_DATA structures that contains the data values\r
+ that are to be set into the given report\r
+\r
+ DataLength As input, length in array elements of DataList. As output,\r
+ contains the number of data elements set on successful\r
+ completion or an index into the DataList array to identify\r
+ the faulting HIDP_DATA value if an error code is returned.\r
+\r
+ PreparasedData Preparsed data structure returned by HIDCLASS\r
+\r
+ Report Buffer which to set the data into.\r
+\r
+ ReportLength Length of Report...Report should be at least as long as the\r
+ value indicated in the HIDP_CAPS structure for the device and\r
+ the corresponding ReportType\r
+\r
+Return Value\r
+ HidP_SetData returns the following error codes. The report packet will\r
+ have all the data set up until the HIDP_DATA structure that caused the\r
+ error. DataLength, in the error case, will return this problem index.\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successful insertion of all data\r
+ into the report packet.\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_DATA_INDEX_NOT_FOUND -- if a HIDP_DATA structure referenced a\r
+ data index that does not exist for this\r
+ device's ReportType\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal\r
+ to the length specified in HIDP_CAPS\r
+ structure for the given ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_IS_USAGE_VALUE_ARRAY -- if one of the HIDP_DATA structures\r
+ references a usage value array.\r
+ DataLength will contain the index into\r
+ the array that was invalid\r
+· HIDP_STATUS_BUTTON_NOT_PRESSED -- if a HIDP_DATA structure attempted\r
+ to unset a button that was not already\r
+ set in the Report\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- a HIDP_DATA structure was found with\r
+ a valid index value but is contained\r
+ in a different report than the one\r
+ currently being processed\r
+· HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough entries in\r
+ a given Main Array Item to report all\r
+ buttons that have been requested to be\r
+ set\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetData (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ OUT PHIDP_DATA DataList,\r
+ IN OUT PULONG DataLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Please Note: For obvious reasons HidP_SetData and HidP_GetData will not\r
+ access UsageValueArrays.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
+\r
+ DataList Array of HIDP_DATA structures that will receive the data\r
+ values that are set in the given report\r
+\r
+ DataLength As input, length in array elements of DataList. As output,\r
+ contains the number of data elements that were successfully\r
+ set by HidP_GetData. The maximum size necessary for DataList\r
+ can be determined by calling HidP_MaxDataListLength\r
+\r
+ PreparasedData Preparsed data structure returned by HIDCLASS\r
+\r
+ Report Buffer which to set the data into.\r
+\r
+ ReportLength Length of Report...Report should be at least as long as the\r
+ value indicated in the HIDP_CAPS structure for the device and\r
+ the corresponding ReportType\r
+\r
+Return Value\r
+ HidP_GetData returns the following error codes.\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successful retrieval of all data\r
+ from the report packet.\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal\r
+ to the length specified in HIDP_CAPS\r
+ structure for the given ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough array entries in\r
+ DataList to store all the indice values\r
+ in the given report. DataLength will\r
+ contain the number of array entries\r
+ required to hold all data\r
+--*/\r
+\r
+ULONG __stdcall\r
+HidP_MaxDataListLength (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+ );\r
+/*++\r
+Routine Description:\r
+\r
+ This function returns the maximum length of HIDP_DATA elements that\r
+ HidP_GetData could return for the given report type.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
+\r
+ PreparsedData Preparsed data structure returned by HIDCLASS\r
+\r
+Return Value:\r
+\r
+ The length of the data list array required for the HidP_GetData function\r
+ call. If an error occurs (either HIDP_STATUS_INVALID_REPORT_TYPE or\r
+ HIDP_STATUS_INVALID_PREPARSED_DATA), this function returns 0.\r
+\r
+--*/\r
+\r
+#define HidP_SetButtons(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) \\r
+ HidP_SetUsages(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle)\r
+\r
+NTSTATUS __stdcall\r
+HidP_SetUsages (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN PUSAGE UsageList,\r
+ IN OUT PULONG UsageLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN OUT PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+/*++\r
+\r
+Routine Description:\r
+ This function sets binary values (buttons) in a report. Given an\r
+ initialized packet of correct length, it modifies the report packet so that\r
+ each element in the given list of usages has been set in the report packet.\r
+ For example, in an output report with 5 LED\92s, each with a given usage,\r
+ an application could turn on any subset of these lights by placing their\r
+ usages in any order into the usage array (UsageList). HidP_SetUsages would,\r
+ in turn, set the appropriate bit or add the corresponding byte into the\r
+ HID Main Array Item.\r
+\r
+ A properly initialized Report packet is one of the correct byte length,\r
+ and all zeros.\r
+\r
+ NOTE: A packet that has already been set with a call to a HidP_Set routine\r
+ can also be passed in. This routine then sets processes the UsageList\r
+ in the same fashion but verifies that the ReportID already set in\r
+ Report matches the report ID for the given usages.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
+\r
+ UsagePage All of the usages in the usage array, which HidP_SetUsages will\r
+ set in the report, refer to this same usage page.\r
+ If a client wishes to set usages in a report for multiple\r
+ usage pages then that client needs to make multiple calls to\r
+ HidP_SetUsages for each of the usage pages.\r
+\r
+ UsageList A usage array containing the usages that HidP_SetUsages will set in\r
+ the report packet.\r
+\r
+ UsageLength The length of the given usage array in array elements.\r
+ The parser will set this value to the position in the usage\r
+ array where it stopped processing. If successful, UsageLength\r
+ will be unchanged. In any error condition, this parameter\r
+ reflects how many of the usages in the usage list have\r
+ actually been set by the parser. This is useful for finding\r
+ the usage in the list which caused the error.\r
+\r
+ PreparsedData The preparsed data recevied from HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length of the given report packet...Must be equal to the\r
+ value reported in the HIDP_CAPS structure for the device\r
+ and corresponding report type.\r
+\r
+Return Value\r
+ HidP_SetUsages returns the following error codes. On error, the report packet\r
+ will be correct up until the usage element that caused the error.\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successful insertion of all usages\r
+ into the report packet.\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if a usage was found that exists in a\r
+ different report. If the report is\r
+ zero-initialized on entry the first\r
+ usage in the list will determine which\r
+ report ID is used. Otherwise, the\r
+ parser will verify that usage matches\r
+ the passed in report's ID\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage does not exist for any\r
+ report (no matter what the report ID)\r
+ for the given report type.\r
+· HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough entries in a\r
+ given Main Array Item to list all of\r
+ the given usages. The caller needs\r
+ to split his request into more than\r
+ one call\r
+--*/\r
+\r
+#define HidP_UnsetButtons(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) \\r
+ HidP_UnsetUsages(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle)\r
+\r
+NTSTATUS __stdcall\r
+HidP_UnsetUsages (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN PUSAGE UsageList,\r
+ IN OUT PULONG UsageLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN OUT PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+/*++\r
+\r
+Routine Description:\r
+ This function unsets (turns off) binary values (buttons) in the report. Given\r
+ an initialized packet of correct length, it modifies the report packet so\r
+ that each element in the given list of usages has been unset in the\r
+ report packet.\r
+\r
+ This function is the "undo" operation for SetUsages. If the given usage\r
+ is not already set in the Report, it will return an error code of\r
+ HIDP_STATUS_BUTTON_NOT_PRESSED. If the button is pressed, HidP_UnsetUsages\r
+ will unset the appropriate bit or remove the corresponding index value from\r
+ the HID Main Array Item.\r
+\r
+ A properly initialized Report packet is one of the correct byte length,\r
+ and all zeros..\r
+\r
+ NOTE: A packet that has already been set with a call to a HidP_Set routine\r
+ can also be passed in. This routine then processes the UsageList\r
+ in the same fashion but verifies that the ReportID already set in\r
+ Report matches the report ID for the given usages.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
+\r
+ UsagePage All of the usages in the usage array, which HidP_UnsetUsages will\r
+ unset in the report, refer to this same usage page.\r
+ If a client wishes to unset usages in a report for multiple\r
+ usage pages then that client needs to make multiple calls to\r
+ HidP_UnsetUsages for each of the usage pages.\r
+\r
+ UsageList A usage array containing the usages that HidP_UnsetUsages will\r
+ unset in the report packet.\r
+\r
+ UsageLength The length of the given usage array in array elements.\r
+ The parser will set this value to the position in the usage\r
+ array where it stopped processing. If successful, UsageLength\r
+ will be unchanged. In any error condition, this parameter\r
+ reflects how many of the usages in the usage list have\r
+ actually been unset by the parser. This is useful for finding\r
+ the usage in the list which caused the error.\r
+\r
+ PreparsedData The preparsed data recevied from HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length of the given report packet...Must be equal to the\r
+ value reported in the HIDP_CAPS structure for the device\r
+ and corresponding report type.\r
+\r
+Return Value\r
+ HidP_UnsetUsages returns the following error codes. On error, the report\r
+ packet will be correct up until the usage element that caused the error.\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successful "unsetting" of all usages\r
+ in the report packet.\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if a usage was found that exists in a\r
+ different report. If the report is\r
+ zero-initialized on entry the first\r
+ usage in the list will determine which\r
+ report ID is used. Otherwise, the\r
+ parser will verify that usage matches\r
+ the passed in report's ID\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage does not exist for any\r
+ report (no matter what the report ID)\r
+ for the given report type.\r
+· HIDP_STATUS_BUTTON_NOT_PRESSED -- if a usage corresponds to a button that\r
+ is not already set in the given report\r
+--*/\r
+\r
+#define HidP_GetButtons(Rty, UPa, LCo, ULi, ULe, Ppd, Rep, RLe) \\r
+ HidP_GetUsages(Rty, UPa, LCo, ULi, ULe, Ppd, Rep, RLe)\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetUsages (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ OUT USAGE * UsageList,\r
+ IN OUT ULONG * UsageLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+/*++\r
+\r
+Routine Description:\r
+ This function returns the binary values (buttons) that are set in a HID\r
+ report. Given a report packet of correct length, it searches the report\r
+ packet for each usage for the given usage page and returns them in the\r
+ usage list.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
+\r
+ UsagePage All of the usages in the usage list, which HidP_GetUsages will\r
+ retrieve in the report, refer to this same usage page.\r
+ If the client wishes to get usages in a packet for multiple\r
+ usage pages then that client needs to make multiple calls\r
+ to HidP_GetUsages.\r
+\r
+ LinkCollection An optional value which can limit which usages are returned\r
+ in the UsageList to those usages that exist in a specific\r
+ LinkCollection. A non-zero value indicates the index into\r
+ the HIDP_LINK_COLLECITON_NODE list returned by\r
+ HidP_GetLinkCollectionNodes of the link collection the\r
+ usage should belong to. A value of 0 indicates this\r
+ should value be ignored.\r
+\r
+ UsageList The usage array that will contain all the usages found in\r
+ the report packet.\r
+\r
+ UsageLength The length of the given usage array in array elements.\r
+ On input, this value describes the length of the usage list.\r
+ On output, HidP_GetUsages sets this value to the number of\r
+ usages that was found. Use HidP_MaxUsageListLength to\r
+ determine the maximum length needed to return all the usages\r
+ that a given report packet may contain.\r
+\r
+ PreparsedData Preparsed data structure returned by HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length (in bytes) of the given report packet\r
+\r
+\r
+Return Value\r
+ HidP_GetUsages returns the following error codes:\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successfully retrieving all the\r
+ usages from the report packet\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_BUFFER_TOO_SMALL -- if the UsageList is not big enough to\r
+ hold all the usages found in the report\r
+ packet. If this is returned, the buffer\r
+ will contain UsageLength number of\r
+ usages. Use HidP_MaxUsageListLength to\r
+ find the maximum length needed\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if no usages were found but usages\r
+ that match the UsagePage and\r
+ LinkCollection specified could be found\r
+ in a report with a different report ID\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if there are no usages in a reports for\r
+ the device and ReportType that match the\r
+ UsagePage and LinkCollection that were\r
+ specified\r
+--*/\r
+\r
+#define HidP_GetButtonsEx(Rty, LCo, BLi, ULe, Ppd, Rep, RLe) \\r
+ HidP_GetUsagesEx(Rty, LCo, BLi, ULe, Ppd, Rep, RLe)\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetUsagesEx (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USHORT LinkCollection, // Optional\r
+ OUT PUSAGE_AND_PAGE ButtonList,\r
+ IN OUT ULONG * UsageLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+\r
+/*++\r
+\r
+Routine Description:\r
+ This function returns the binary values (buttons) in a HID report.\r
+ Given a report packet of correct length, it searches the report packet\r
+ for all buttons and returns the UsagePage and Usage for each of the buttons\r
+ it finds.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
+\r
+ LinkCollection An optional value which can limit which usages are returned\r
+ in the ButtonList to those usages that exist in a specific\r
+ LinkCollection. A non-zero value indicates the index into\r
+ the HIDP_LINK_COLLECITON_NODE list returned by\r
+ HidP_GetLinkCollectionNodes of the link collection the\r
+ usage should belong to. A value of 0 indicates this\r
+ should value be ignored.\r
+\r
+ ButtonList An array of USAGE_AND_PAGE structures describing all the\r
+ buttons currently ``down'' in the device.\r
+\r
+ UsageLength The length of the given array in terms of elements.\r
+ On input, this value describes the length of the list. On\r
+ output, HidP_GetUsagesEx sets this value to the number of\r
+ usages that were found. Use HidP_MaxUsageListLength to\r
+ determine the maximum length needed to return all the usages\r
+ that a given report packet may contain.\r
+\r
+ PreparsedData Preparsed data returned by HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length (in bytes) of the given report packet.\r
+\r
+\r
+Return Value\r
+ HidP_GetUsagesEx returns the following error codes:\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successfully retrieving all the\r
+ usages from the report packet\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_BUFFER_TOO_SMALL -- if ButtonList is not big enough to\r
+ hold all the usages found in the report\r
+ packet. If this is returned, the buffer\r
+ will contain UsageLength number of\r
+ usages. Use HidP_MaxUsageListLength to\r
+ find the maximum length needed\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if no usages were found but usages\r
+ that match the specified LinkCollection\r
+ exist in report with a different report\r
+ ID.\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if there are no usages in any reports that\r
+ match the LinkCollection parameter\r
+--*/\r
+\r
+#define HidP_GetButtonListLength(RTy, UPa, Ppd) \\r
+ HidP_GetUsageListLength(Rty, UPa, Ppd)\r
+\r
+ULONG __stdcall\r
+HidP_MaxUsageListLength (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage, // Optional\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function returns the maximum number of usages that a call to\r
+ HidP_GetUsages or HidP_GetUsagesEx could return for a given HID report.\r
+ If calling for number of usages returned by HidP_GetUsagesEx, use 0 as\r
+ the UsagePage value.\r
+\r
+Parameters:\r
+ ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
+\r
+ UsagePage Specifies the optional UsagePage to query for. If 0, will\r
+ return all the maximum number of usage values that could be\r
+ returned for a given ReportType. If non-zero, will return\r
+ the maximum number of usages that would be returned for the\r
+ ReportType with the given UsagePage.\r
+\r
+ PreparsedData Preparsed data returned from HIDCLASS\r
+\r
+Return Value:\r
+ The length of the usage list array required for the HidP_GetUsages or\r
+ HidP_GetUsagesEx function call. If an error occurs (such as\r
+ HIDP_STATUS_INVALID_REPORT_TYPE or HIDP_INVALID_PREPARSED_DATA, this\r
+ returns 0.\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_SetUsageValue (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN USAGE Usage,\r
+ IN ULONG UsageValue,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN OUT PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+/*++\r
+Description:\r
+ HidP_SetUsageValue inserts a value into the HID Report Packet in the field\r
+ corresponding to the given usage page and usage. HidP_SetUsageValue\r
+ casts this value to the appropriate bit length. If a report packet\r
+ contains two different fields with the same Usage and UsagePage,\r
+ they can be distinguished with the optional LinkCollection field value.\r
+ Using this function sets the raw value into the report packet with\r
+ no checking done as to whether it actually falls within the logical\r
+ minimum/logical maximum range. Use HidP_SetScaledUsageValue for this...\r
+\r
+ NOTE: Although the UsageValue parameter is a ULONG, any casting that is\r
+ done will preserve or sign-extend the value. The value being set\r
+ should be considered a LONG value and will be treated as such by\r
+ this function.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Output or HidP_Feature.\r
+\r
+ UsagePage The usage page to which the given usage refers.\r
+\r
+ LinkCollection (Optional) This value can be used to differentiate\r
+ between two fields that may have the same\r
+ UsagePage and Usage but exist in different\r
+ collections. If the link collection value\r
+ is zero, this function will set the first field\r
+ it finds that matches the usage page and\r
+ usage.\r
+\r
+ Usage The usage whose value HidP_SetUsageValue will set.\r
+\r
+ UsageValue The raw value to set in the report buffer. This value must be within\r
+ the logical range or if a NULL value this value should be the\r
+ most negative value that can be represented by the number of bits\r
+ for this field.\r
+\r
+ PreparsedData The preparsed data returned for HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length (in bytes) of the given report packet.\r
+\r
+\r
+Return Value:\r
+ HidP_SetUsageValue returns the following error codes:\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successfully setting the value\r
+ in the report packet\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
+ link collection exist but exists in\r
+ a report with a different report ID\r
+ than the report being passed in. To\r
+ set this value, call HidP_SetUsageValue\r
+ again with a zero-initizialed report\r
+ packet\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
+ collection combination does not exist\r
+ in any reports for this ReportType\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_SetScaledUsageValue (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN USAGE Usage,\r
+ IN LONG UsageValue,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN OUT PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+\r
+/*++\r
+Description:\r
+ HidP_SetScaledUsageValue inserts the UsageValue into the HID report packet\r
+ in the field corresponding to the given usage page and usage. If a report\r
+ packet contains two different fields with the same Usage and UsagePage,\r
+ they can be distinguished with the optional LinkCollection field value.\r
+\r
+ If the specified field has a defined physical range, this function converts\r
+ the physical value specified to the corresponding logical value for the\r
+ report. If a physical value does not exist, the function will verify that\r
+ the value specified falls within the logical range and set according.\r
+\r
+ If the range checking fails but the field has NULL values, the function will\r
+ set the field to the defined NULL value (most negative number possible) and\r
+ return HIDP_STATUS_NULL. In other words, use this function to set NULL\r
+ values for a given field by passing in a value that falls outside the\r
+ physical range if it is defined or the logical range otherwise.\r
+\r
+ If the field does not support NULL values, an out of range error will be\r
+ returned instead.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Output or HidP_Feature.\r
+\r
+ UsagePage The usage page to which the given usage refers.\r
+\r
+ LinkCollection (Optional) This value can be used to differentiate\r
+ between two fields that may have the same\r
+ UsagePage and Usage but exist in different\r
+ collections. If the link collection value\r
+ is zero, this function will set the first field\r
+ it finds that matches the usage page and\r
+ usage.\r
+\r
+ Usage The usage whose value HidP_SetScaledUsageValue will set.\r
+\r
+ UsageValue The value to set in the report buffer. See the routine\r
+ description above for the different interpretations of this\r
+ value\r
+\r
+ PreparsedData The preparsed data returned from HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length (in bytes) of the given report packet.\r
+\r
+\r
+Return Value:\r
+ HidP_SetScaledUsageValue returns the following error codes:\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successfully setting the value\r
+ in the report packet\r
+· HIDP_STATUS_NULL -- upon successfully setting the value\r
+ in the report packet as a NULL value\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_VALUE_OUT_OF_RANGE -- if the value specified failed to fall\r
+ within the physical range if it exists\r
+ or within the logical range otherwise\r
+ and the field specified by the usage\r
+ does not allow NULL values\r
+· HIDP_STATUS_BAD_LOG_PHY_VALUES -- if the field has a physical range but\r
+ either the logical range is invalid\r
+ (max <= min) or the physical range is\r
+ invalid\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
+ link collection exist but exists in\r
+ a report with a different report ID\r
+ than the report being passed in. To\r
+ set this value, call\r
+ HidP_SetScaledUsageValue again with\r
+ a zero-initialized report packet\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
+ collection combination does not exist\r
+ in any reports for this ReportType\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_SetUsageValueArray (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN USAGE Usage,\r
+ IN PCHAR UsageValue,\r
+ IN USHORT UsageValueByteLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ OUT PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+\r
+/*++\r
+Routine Descripton:\r
+ A usage value array occurs when the last usage in the list of usages\r
+ describing a main item must be repeated because there are less usages defined\r
+ than there are report counts declared for the given main item. In this case\r
+ a single value cap is allocated for that usage and the report count of that\r
+ value cap is set to reflect the number of fields to which that usage refers.\r
+\r
+ HidP_SetUsageValueArray sets the raw bits for that usage which spans\r
+ more than one field in a report.\r
+\r
+ NOTE: This function currently does not support value arrays where the\r
+ ReportSize for each of the fields in the array is not a multiple\r
+ of 8 bits.\r
+\r
+ The UsageValue buffer should have the values set as they would appear\r
+ in the report buffer. If this function supported non 8-bit multiples\r
+ for the ReportSize then caller should format the input buffer so that\r
+ each new value begins at the bit immediately following the last bit\r
+ of the previous value\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Output or HidP_Feature.\r
+\r
+ UsagePage The usage page to which the given usage refers.\r
+\r
+ LinkCollection (Optional) This value can be used to differentiate\r
+ between two fields that may have the same\r
+ UsagePage and Usage but exist in different\r
+ collections. If the link collection value\r
+ is zero, this function will set the first field\r
+ it finds that matches the usage page and\r
+ usage.\r
+\r
+ Usage The usage whose value array HidP_SetUsageValueArray will set.\r
+\r
+ UsageValue The buffer with the values to set into the value array.\r
+ The number of BITS required is found by multiplying the\r
+ BitSize and ReportCount fields of the Value Cap for this\r
+ control. The least significant bit of this control found in the\r
+ given report will be placed in the least significan bit location\r
+ of the array given (little-endian format), regardless of whether\r
+ or not the field is byte alligned or if the BitSize is a multiple\r
+ of sizeof (CHAR).\r
+\r
+ See the above note for current implementation limitations.\r
+\r
+ UsageValueByteLength Length of the UsageValue buffer (in bytes)\r
+\r
+ PreparsedData The preparsed data returned from HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length (in bytes) of the given report packet.\r
+\r
+\r
+Return Value:\r
+· HIDP_STATUS_SUCCESS -- upon successfully setting the value\r
+ array in the report packet\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_NOT_VALUE_ARRAY -- if the control specified is not a\r
+ value array -- a value array will have\r
+ a ReportCount field in the\r
+ HIDP_VALUE_CAPS structure that is > 1\r
+ Use HidP_SetUsageValue instead\r
+· HIDP_STATUS_BUFFER_TOO_SMALL -- if the size of the passed in buffer with\r
+ the values to set is too small (ie. has\r
+ fewer values than the number of fields in\r
+ the array\r
+· HIDP_STATUS_NOT_IMPLEMENTED -- if the usage value array has field sizes\r
+ that are not multiples of 8 bits, this\r
+ error code is returned since the function\r
+ currently does not handle setting into\r
+ such arrays.\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
+ link collection exist but exists in\r
+ a report with a different report ID\r
+ than the report being passed in. To\r
+ set this value, call\r
+ HidP_SetUsageValueArray again with\r
+ a zero-initialized report packet\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
+ collection combination does not exist\r
+ in any reports for this ReportType\r
+--*/\r
+\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetUsageValue (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN USAGE Usage,\r
+ OUT PULONG UsageValue,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+\r
+/*\r
+Description\r
+ HidP_GetUsageValue retrieves the value from the HID Report for the usage\r
+ specified by the combination of usage page, usage and link collection.\r
+ If a report packet contains two different fields with the same\r
+ Usage and UsagePage, they can be distinguished with the optional\r
+ LinkCollection field value.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Input or HidP_Feature.\r
+\r
+ UsagePage The usage page to which the given usage refers.\r
+\r
+ LinkCollection (Optional) This value can be used to differentiate\r
+ between two fields that may have the same\r
+ UsagePage and Usage but exist in different\r
+ collections. If the link collection value\r
+ is zero, this function will set the first field\r
+ it finds that matches the usage page and\r
+ usage.\r
+\r
+ Usage The usage whose value HidP_GetUsageValue will retrieve\r
+\r
+ UsageValue The raw value that is set for the specified field in the report\r
+ buffer. This value will either fall within the logical range\r
+ or if NULL values are allowed, a number outside the range to\r
+ indicate a NULL\r
+\r
+ PreparsedData The preparsed data returned for HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length (in bytes) of the given report packet.\r
+\r
+\r
+Return Value:\r
+ HidP_GetUsageValue returns the following error codes:\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successfully retrieving the value\r
+ from the report packet\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
+ for the given ReportType\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
+ link collection exist but exists in\r
+ a report with a different report ID\r
+ than the report being passed in. To\r
+ set this value, call HidP_GetUsageValue\r
+ again with a different report packet\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
+ collection combination does not exist\r
+ in any reports for this ReportType\r
+--*/\r
+\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetScaledUsageValue (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN USAGE Usage,\r
+ OUT PLONG UsageValue,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+\r
+/*++\r
+Description\r
+ HidP_GetScaledUsageValue retrieves a UsageValue from the HID report packet\r
+ in the field corresponding to the given usage page and usage. If a report\r
+ packet contains two different fields with the same Usage and UsagePage,\r
+ they can be distinguished with the optional LinkCollection field value.\r
+\r
+ If the specified field has a defined physical range, this function converts\r
+ the logical value that exists in the report packet to the corresponding\r
+ physical value. If a physical range does not exist, the function will\r
+ return the logical value. This function will check to verify that the\r
+ logical value in the report falls within the declared logical range.\r
+\r
+ When doing the conversion between logical and physical values, this\r
+ function assumes a linear extrapolation between the physical max/min and\r
+ the logical max/min. (Where logical is the values reported by the device\r
+ and physical is the value returned by this function). If the data field\r
+ size is less than 32 bits, then HidP_GetScaledUsageValue will sign extend\r
+ the value to 32 bits.\r
+\r
+ If the range checking fails but the field has NULL values, the function\r
+ will set UsageValue to 0 and return HIDP_STATUS_NULL. Otherwise, it\r
+ returns a HIDP_STATUS_OUT_OF_RANGE error.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Output or HidP_Feature.\r
+\r
+ UsagePage The usage page to which the given usage refers.\r
+\r
+ LinkCollection (Optional) This value can be used to differentiate\r
+ between two fields that may have the same\r
+ UsagePage and Usage but exist in different\r
+ collections. If the link collection value\r
+ is zero, this function will retrieve the first\r
+ field it finds that matches the usage page\r
+ and usage.\r
+\r
+ Usage The usage whose value HidP_GetScaledUsageValue will retrieve\r
+\r
+ UsageValue The value retrieved from the report buffer. See the routine\r
+ description above for the different interpretations of this\r
+ value\r
+\r
+ PreparsedData The preparsed data returned from HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length (in bytes) of the given report packet.\r
+\r
+\r
+Return Value:\r
+ HidP_GetScaledUsageValue returns the following error codes:\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successfully retrieving the value\r
+ from the report packet\r
+· HIDP_STATUS_NULL -- if the report packet had a NULL value\r
+ set\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_VALUE_OUT_OF_RANGE -- if the value retrieved from the packet\r
+ falls outside the logical range and\r
+ the field does not support NULL values\r
+· HIDP_STATUS_BAD_LOG_PHY_VALUES -- if the field has a physical range but\r
+ either the logical range is invalid\r
+ (max <= min) or the physical range is\r
+ invalid\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
+ link collection exist but exists in\r
+ a report with a different report ID\r
+ than the report being passed in. To\r
+ set this value, call\r
+ HidP_GetScaledUsageValue with a\r
+ different report packet\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
+ collection combination does not exist\r
+ in any reports for this ReportType\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_GetUsageValueArray (\r
+ IN HIDP_REPORT_TYPE ReportType,\r
+ IN USAGE UsagePage,\r
+ IN USHORT LinkCollection, // Optional\r
+ IN USAGE Usage,\r
+ OUT PCHAR UsageValue,\r
+ IN USHORT UsageValueByteLength,\r
+ IN PHIDP_PREPARSED_DATA PreparsedData,\r
+ IN PCHAR Report,\r
+ IN ULONG ReportLength\r
+ );\r
+\r
+/*++\r
+Routine Descripton:\r
+ A usage value array occurs when the last usage in the list of usages\r
+ describing a main item must be repeated because there are less usages defined\r
+ than there are report counts declared for the given main item. In this case\r
+ a single value cap is allocated for that usage and the report count of that\r
+ value cap is set to reflect the number of fields to which that usage refers.\r
+\r
+ HidP_GetUsageValueArray returns the raw bits for that usage which spans\r
+ more than one field in a report.\r
+\r
+ NOTE: This function currently does not support value arrays where the\r
+ ReportSize for each of the fields in the array is not a multiple\r
+ of 8 bits.\r
+\r
+ The UsageValue buffer will have the raw values as they are set\r
+ in the report packet.\r
+\r
+Parameters:\r
+\r
+ ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
+\r
+ UsagePage The usage page to which the given usage refers.\r
+\r
+ LinkCollection (Optional) This value can be used to differentiate\r
+ between two fields that may have the same\r
+ UsagePage and Usage but exist in different\r
+ collections. If the link collection value\r
+ is zero, this function will set the first field\r
+ it finds that matches the usage page and\r
+ usage.\r
+\r
+ Usage The usage whose value HidP_GetUsageValueArray will retreive.\r
+\r
+ UsageValue A pointer to an array of characters where the value will be\r
+ placed. The number of BITS required is found by multiplying the\r
+ BitSize and ReportCount fields of the Value Cap for this\r
+ control. The least significant bit of this control found in the\r
+ given report will be placed in the least significant bit location\r
+ of the buffer (little-endian format), regardless of whether\r
+ or not the field is byte aligned or if the BitSize is a multiple\r
+ of sizeof (CHAR).\r
+\r
+ See note above about current implementation limitations\r
+\r
+ UsageValueByteLength\r
+ the length of the given UsageValue buffer.\r
+\r
+ PreparsedData The preparsed data returned by the HIDCLASS\r
+\r
+ Report The report packet.\r
+\r
+ ReportLength Length of the given report packet.\r
+\r
+Return Value:\r
+\r
+· HIDP_STATUS_SUCCESS -- upon successfully retrieving the value\r
+ from the report packet\r
+· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
+· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
+· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
+ equal to the length specified in\r
+ the HIDP_CAPS structure for the given\r
+ ReportType\r
+· HIDP_STATUS_NOT_VALUE_ARRAY -- if the control specified is not a\r
+ value array -- a value array will have\r
+ a ReportCount field in the\r
+ HIDP_VALUE_CAPS structure that is > 1\r
+ Use HidP_GetUsageValue instead\r
+· HIDP_STATUS_BUFFER_TOO_SMALL -- if the size of the passed in buffer in\r
+ which to return the array is too small\r
+ (ie. has fewer values than the number of\r
+ fields in the array\r
+· HIDP_STATUS_NOT_IMPLEMENTED -- if the usage value array has field sizes\r
+ that are not multiples of 8 bits, this\r
+ error code is returned since the function\r
+ currently does not handle getting values\r
+ from such arrays.\r
+· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
+ link collection exist but exists in\r
+ a report with a different report ID\r
+ than the report being passed in. To\r
+ set this value, call\r
+ HidP_GetUsageValueArray with a\r
+ different report packet\r
+· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
+ collection combination does not exist\r
+ in any reports for this ReportType\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_UsageListDifference (\r
+ IN PUSAGE PreviousUsageList,\r
+ IN PUSAGE CurrentUsageList,\r
+ OUT PUSAGE BreakUsageList,\r
+ OUT PUSAGE MakeUsageList,\r
+ IN ULONG UsageListLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function will return the difference between a two lists of usages\r
+ (as might be returned from HidP_GetUsages), In other words, it will return\r
+ return a list of usages that are in the current list but not the previous\r
+ list as well as a list of usages that are in the previous list but not\r
+ the current list.\r
+\r
+Parameters:\r
+\r
+ PreviousUsageList The list of usages before.\r
+ CurrentUsageList The list of usages now.\r
+ BreakUsageList Previous - Current.\r
+ MakeUsageList Current - Previous.\r
+ UsageListLength Represents the length of the usage lists in array\r
+ elements. If comparing two lists with a differing\r
+ number of array elements, this value should be\r
+ the size of the larger of the two lists. Any\r
+ zero found with a list indicates an early termination\r
+ of the list and any usages found after the first zero\r
+ will be ignored.\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_UsageAndPageListDifference (\r
+ IN PUSAGE_AND_PAGE PreviousUsageList,\r
+ IN PUSAGE_AND_PAGE CurrentUsageList,\r
+ OUT PUSAGE_AND_PAGE BreakUsageList,\r
+ OUT PUSAGE_AND_PAGE MakeUsageList,\r
+ IN ULONG UsageListLength\r
+ );\r
+\r
+//\r
+// Produce Make or Break Codes\r
+//\r
+typedef enum _HIDP_KEYBOARD_DIRECTION {\r
+ HidP_Keyboard_Break,\r
+ HidP_Keyboard_Make\r
+} HIDP_KEYBOARD_DIRECTION;\r
+\r
+//\r
+// A bitmap of the current shift state of the keyboard when using the\r
+// below keyboard usages to i8042 translation function.\r
+//\r
+typedef struct _HIDP_KEYBOARD_MODIFIER_STATE {\r
+ union {\r
+ struct {\r
+ ULONG LeftControl: 1;\r
+ ULONG LeftShift: 1;\r
+ ULONG LeftAlt: 1;\r
+ ULONG LeftGUI: 1;\r
+ ULONG RightControl: 1;\r
+ ULONG RightShift: 1;\r
+ ULONG RightAlt: 1;\r
+ ULONG RigthGUI: 1;\r
+ ULONG CapsLock: 1;\r
+ ULONG ScollLock: 1;\r
+ ULONG NumLock: 1;\r
+ ULONG Reserved: 21;\r
+ };\r
+ ULONG ul;\r
+ };\r
+\r
+} HIDP_KEYBOARD_MODIFIER_STATE, * PHIDP_KEYBOARD_MODIFIER_STATE;\r
+\r
+//\r
+// A call back function to give the i8042 scan codes to the caller of\r
+// the below translation function.\r
+//\r
+typedef BOOLEAN (* PHIDP_INSERT_SCANCODES) (\r
+ IN PVOID Context, // Some caller supplied context.\r
+ IN PCHAR NewScanCodes, // A list of i8042 scan codes.\r
+ IN ULONG Length // the length of the scan codes.\r
+ );\r
+\r
+NTSTATUS __stdcall\r
+HidP_TranslateUsageAndPagesToI8042ScanCodes (\r
+ IN PUSAGE_AND_PAGE ChangedUsageList,\r
+ IN ULONG UsageListLength,\r
+ IN HIDP_KEYBOARD_DIRECTION KeyAction,\r
+ IN OUT PHIDP_KEYBOARD_MODIFIER_STATE ModifierState,\r
+ IN PHIDP_INSERT_SCANCODES InsertCodesProcedure,\r
+ IN PVOID InsertCodesContext\r
+ );\r
+/*++\r
+Routine Description:\r
+Parameters:\r
+--*/\r
+\r
+NTSTATUS __stdcall\r
+HidP_TranslateUsagesToI8042ScanCodes (\r
+ IN PUSAGE ChangedUsageList,\r
+ IN ULONG UsageListLength,\r
+ IN HIDP_KEYBOARD_DIRECTION KeyAction,\r
+ IN OUT PHIDP_KEYBOARD_MODIFIER_STATE ModifierState,\r
+ IN PHIDP_INSERT_SCANCODES InsertCodesProcedure,\r
+ IN PVOID InsertCodesContext\r
+ );\r
+/*++\r
+Routine Description:\r
+Parameters:\r
+--*/\r
+\r
+\r
+\r
+//\r
+// Define NT Status codes with Facility Code of FACILITY_HID_ERROR_CODE\r
+//\r
+\r
+// FACILITY_HID_ERROR_CODE defined in ntstatus.h\r
+#ifndef FACILITY_HID_ERROR_CODE\r
+#define FACILITY_HID_ERROR_CODE 0x11\r
+#endif\r
+\r
+#define HIDP_ERROR_CODES(SEV, CODE) \\r
+ ((NTSTATUS) (((SEV) << 28) | (FACILITY_HID_ERROR_CODE << 16) | (CODE)))\r
+\r
+#define HIDP_STATUS_SUCCESS (HIDP_ERROR_CODES(0x0,0))\r
+#define HIDP_STATUS_NULL (HIDP_ERROR_CODES(0x8,1))\r
+#define HIDP_STATUS_INVALID_PREPARSED_DATA (HIDP_ERROR_CODES(0xC,1))\r
+#define HIDP_STATUS_INVALID_REPORT_TYPE (HIDP_ERROR_CODES(0xC,2))\r
+#define HIDP_STATUS_INVALID_REPORT_LENGTH (HIDP_ERROR_CODES(0xC,3))\r
+#define HIDP_STATUS_USAGE_NOT_FOUND (HIDP_ERROR_CODES(0xC,4))\r
+#define HIDP_STATUS_VALUE_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,5))\r
+#define HIDP_STATUS_BAD_LOG_PHY_VALUES (HIDP_ERROR_CODES(0xC,6))\r
+#define HIDP_STATUS_BUFFER_TOO_SMALL (HIDP_ERROR_CODES(0xC,7))\r
+#define HIDP_STATUS_INTERNAL_ERROR (HIDP_ERROR_CODES(0xC,8))\r
+#define HIDP_STATUS_I8042_TRANS_UNKNOWN (HIDP_ERROR_CODES(0xC,9))\r
+#define HIDP_STATUS_INCOMPATIBLE_REPORT_ID (HIDP_ERROR_CODES(0xC,0xA))\r
+#define HIDP_STATUS_NOT_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xB))\r
+#define HIDP_STATUS_IS_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xC))\r
+#define HIDP_STATUS_DATA_INDEX_NOT_FOUND (HIDP_ERROR_CODES(0xC,0xD))\r
+#define HIDP_STATUS_DATA_INDEX_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,0xE))\r
+#define HIDP_STATUS_BUTTON_NOT_PRESSED (HIDP_ERROR_CODES(0xC,0xF))\r
+#define HIDP_STATUS_REPORT_DOES_NOT_EXIST (HIDP_ERROR_CODES(0xC,0x10))\r
+#define HIDP_STATUS_NOT_IMPLEMENTED (HIDP_ERROR_CODES(0xC,0x20))\r
+\r
+//\r
+// We blundered this status code.\r
+//\r
+#define HIDP_STATUS_I8242_TRANS_UNKNOWN HIDP_STATUS_I8042_TRANS_UNKNOWN\r
+\r
+#include <poppack.h>\r
+\r
+#endif\r
--- /dev/null
+/*++\r
+\r
+Copyright (c) 1996 Microsoft Corporation\r
+\r
+Module Name:\r
+\r
+ HIDSDI.H\r
+\r
+Abstract:\r
+\r
+ This module contains the PUBLIC definitions for the\r
+ code that implements the HID dll.\r
+\r
+Environment:\r
+\r
+ Kernel & user mode\r
+\r
+--*/\r
+\r
+\r
+#ifndef _HIDSDI_H\r
+#define _HIDSDI_H\r
+\r
+#include <pshpack4.h>\r
+\r
+//#include "wtypes.h"\r
+\r
+//#include <windef.h>\r
+//#include <win32.h>\r
+//#include <basetyps.h>\r
+\r
+typedef LONG NTSTATUS;\r
+#include "hidusage.h"\r
+#include "hidpi.h"\r
+\r
+typedef struct _HIDD_CONFIGURATION {\r
+ PVOID cookie;\r
+ ULONG size;\r
+ ULONG RingBufferSize;\r
+} HIDD_CONFIGURATION, *PHIDD_CONFIGURATION;\r
+\r
+typedef struct _HIDD_ATTRIBUTES {\r
+ ULONG Size; // = sizeof (struct _HIDD_ATTRIBUTES)\r
+\r
+ //\r
+ // Vendor ids of this hid device\r
+ //\r
+ USHORT VendorID;\r
+ USHORT ProductID;\r
+ USHORT VersionNumber;\r
+\r
+ //\r
+ // Additional fields will be added to the end of this structure.\r
+ //\r
+} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;\r
+\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetAttributes (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PHIDD_ATTRIBUTES Attributes\r
+ );\r
+/*++\r
+Routine Description:\r
+ Fill in the given HIDD_ATTRIBUTES structure with the attributes of the\r
+ given hid device.\r
+\r
+--*/\r
+\r
+\r
+void __stdcall\r
+HidD_GetHidGuid (\r
+ OUT LPGUID HidGuid\r
+ );\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetPreparsedData (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PHIDP_PREPARSED_DATA * PreparsedData\r
+ );\r
+/*++\r
+Routine Description:\r
+ Given a handle to a valid Hid Class Device Object, retrieve the preparsed\r
+ data for the device. This routine will allocate the appropriately \r
+ sized buffer to hold this preparsed data. It is up to client to call\r
+ HidP_FreePreparsedData to free the memory allocated to this structure when\r
+ it is no longer needed.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device that the client obtains using \r
+ a call to CreateFile on a valid Hid device string name.\r
+ The string name can be obtained using standard PnP calls.\r
+\r
+ PreparsedData An opaque data structure used by other functions in this \r
+ library to retrieve information about a given device.\r
+\r
+Return Value:\r
+ TRUE if successful.\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_FreePreparsedData (\r
+ IN PHIDP_PREPARSED_DATA PreparsedData\r
+ );\r
+\r
+BOOLEAN __stdcall\r
+HidD_FlushQueue (\r
+ IN HANDLE HidDeviceObject\r
+ );\r
+/*++\r
+Routine Description:\r
+ Flush the input queue for the given HID device.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device that the client obtains using \r
+ a call to CreateFile on a valid Hid device string name.\r
+ The string name can be obtained using standard PnP calls.\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetConfiguration (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PHIDD_CONFIGURATION Configuration,\r
+ IN ULONG ConfigurationLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ Get the configuration information for this Hid device\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+\r
+ Configuration A configuration structure. HidD_GetConfiguration MUST\r
+ be called before the configuration can be modified and\r
+ set using HidD_SetConfiguration\r
+\r
+ ConfigurationLength That is ``sizeof (HIDD_CONFIGURATION)''. Using this\r
+ parameter, we can later increase the length of the \r
+ configuration array and not break older apps.\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_SetConfiguration (\r
+ IN HANDLE HidDeviceObject,\r
+ IN PHIDD_CONFIGURATION Configuration,\r
+ IN ULONG ConfigurationLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ Set the configuration information for this Hid device...\r
+ \r
+ NOTE: HidD_GetConfiguration must be called to retrieve the current \r
+ configuration information before this information can be modified \r
+ and set.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ Configuration A configuration structure. HidD_GetConfiguration MUST\r
+ be called before the configuration can be modified and\r
+ set using HidD_SetConfiguration\r
+ \r
+ ConfigurationLength That is ``sizeof (HIDD_CONFIGURATION)''. Using this\r
+ parameter, we can later increase the length of the \r
+ configuration array and not break older apps.\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetFeature (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PVOID ReportBuffer,\r
+ IN ULONG ReportBufferLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ Retrieve a feature report from a HID device.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ ReportBuffer The buffer that the feature report should be placed \r
+ into. The first byte of the buffer should be set to\r
+ the report ID of the desired report\r
+ \r
+ ReportBufferLength The size (in bytes) of ReportBuffer. This value \r
+ should be greater than or equal to the \r
+ FeatureReportByteLength field as specified in the \r
+ HIDP_CAPS structure for the device\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_SetFeature (\r
+ IN HANDLE HidDeviceObject,\r
+ IN PVOID ReportBuffer,\r
+ IN ULONG ReportBufferLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ Send a feature report to a HID device.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ ReportBuffer The buffer of the feature report to send to the device\r
+ \r
+ ReportBufferLength The size (in bytes) of ReportBuffer. This value \r
+ should be greater than or equal to the \r
+ FeatureReportByteLength field as specified in the \r
+ HIDP_CAPS structure for the device\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetNumInputBuffers (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PULONG NumberBuffers\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function returns the number of input buffers used by the specified\r
+ file handle to the Hid device. Each file object has a number of buffers\r
+ associated with it to queue reports read from the device but which have\r
+ not yet been read by the user-mode app with a handle to that device.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ NumberBuffers Number of buffers currently being used for this file\r
+ handle to the Hid device\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_SetNumInputBuffers (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT ULONG NumberBuffers\r
+ );\r
+/*++\r
+\r
+Routine Description:\r
+ This function sets the number of input buffers used by the specified\r
+ file handle to the Hid device. Each file object has a number of buffers\r
+ associated with it to queue reports read from the device but which have\r
+ not yet been read by the user-mode app with a handle to that device.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ NumberBuffers New number of buffers to use for this file handle to\r
+ the Hid device\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetPhysicalDescriptor (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PVOID Buffer,\r
+ IN ULONG BufferLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function retrieves the raw physical descriptor for the specified\r
+ Hid device. \r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ Buffer Buffer which on return will contain the physical\r
+ descriptor if one exists for the specified device\r
+ handle\r
+\r
+ BufferLength Length of buffer (in bytes)\r
+\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetManufacturerString (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PVOID Buffer,\r
+ IN ULONG BufferLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function retrieves the manufacturer string from the specified \r
+ Hid device. \r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ Buffer Buffer which on return will contain the manufacturer\r
+ string returned from the device. This string is a \r
+ wide-character string\r
+\r
+ BufferLength Length of Buffer (in bytes)\r
+\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetProductString (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PVOID Buffer,\r
+ IN ULONG BufferLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function retrieves the product string from the specified \r
+ Hid device. \r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ Buffer Buffer which on return will contain the product\r
+ string returned from the device. This string is a \r
+ wide-character string\r
+\r
+ BufferLength Length of Buffer (in bytes)\r
+\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetIndexedString (\r
+ IN HANDLE HidDeviceObject,\r
+ IN ULONG StringIndex,\r
+ OUT PVOID Buffer,\r
+ IN ULONG BufferLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function retrieves a string from the specified Hid device that is\r
+ specified with a certain string index.\r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ StringIndex Index of the string to retrieve\r
+\r
+ Buffer Buffer which on return will contain the product\r
+ string returned from the device. This string is a \r
+ wide-character string\r
+\r
+ BufferLength Length of Buffer (in bytes)\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+BOOLEAN __stdcall\r
+HidD_GetSerialNumberString (\r
+ IN HANDLE HidDeviceObject,\r
+ OUT PVOID Buffer,\r
+ IN ULONG BufferLength\r
+ );\r
+/*++\r
+Routine Description:\r
+ This function retrieves the serial number string from the specified \r
+ Hid device. \r
+\r
+Arguments:\r
+ HidDeviceObject A handle to a Hid Device Object.\r
+ \r
+ Buffer Buffer which on return will contain the serial number\r
+ string returned from the device. This string is a \r
+ wide-character string\r
+\r
+ BufferLength Length of Buffer (in bytes)\r
+\r
+Return Value:\r
+ TRUE if successful\r
+ FALSE otherwise -- Use GetLastError() to get extended error information\r
+--*/\r
+\r
+\r
+#include <poppack.h>\r
+\r
+#endif\r
--- /dev/null
+/*++\r
+\r
+Copyright (c) 1996, 1997 Microsoft Corporation\r
+\r
+Module Name:\r
+\r
+ HIDUSAGE.H\r
+\r
+Abstract:\r
+\r
+ Public Definitions of HID USAGES.\r
+\r
+Environment:\r
+\r
+ Kernel & user mode\r
+\r
+--*/\r
+\r
+#ifndef __HIDUSAGE_H__\r
+#define __HIDUSAGE_H__\r
+\r
+//\r
+// Usage Pages\r
+//\r
+\r
+typedef USHORT USAGE, *PUSAGE;\r
+\r
+#define HID_USAGE_PAGE_GENERIC ((USAGE) 0x01)\r
+#define HID_USAGE_PAGE_SIMULATION ((USAGE) 0x02)\r
+#define HID_USAGE_PAGE_VR ((USAGE) 0x03)\r
+#define HID_USAGE_PAGE_SPORT ((USAGE) 0x04)\r
+#define HID_USAGE_PAGE_GAME ((USAGE) 0x05)\r
+#define HID_USAGE_PAGE_KEYBOARD ((USAGE) 0x07)\r
+#define HID_USAGE_PAGE_LED ((USAGE) 0x08)\r
+#define HID_USAGE_PAGE_BUTTON ((USAGE) 0x09)\r
+#define HID_USAGE_PAGE_ORDINAL ((USAGE) 0x0A)\r
+#define HID_USAGE_PAGE_TELEPHONY ((USAGE) 0x0B)\r
+#define HID_USAGE_PAGE_CONSUMER ((USAGE) 0x0C)\r
+#define HID_USAGE_PAGE_DIGITIZER ((USAGE) 0x0D)\r
+#define HID_USAGE_PAGE_UNICODE ((USAGE) 0x10)\r
+#define HID_USAGE_PAGE_ALPHANUMERIC ((USAGE) 0x14)\r
+\r
+\r
+//\r
+// Usages from Generic Desktop Page (0x01)\r
+//\r
+\r
+#define HID_USAGE_GENERIC_POINTER ((USAGE) 0x01)\r
+#define HID_USAGE_GENERIC_MOUSE ((USAGE) 0x02)\r
+#define HID_USAGE_GENERIC_JOYSTICK ((USAGE) 0x04)\r
+#define HID_USAGE_GENERIC_GAMEPAD ((USAGE) 0x05)\r
+#define HID_USAGE_GENERIC_KEYBOARD ((USAGE) 0x06)\r
+#define HID_USAGE_GENERIC_KEYPAD ((USAGE) 0x07)\r
+#define HID_USAGE_GENERIC_SYSTEM_CTL ((USAGE) 0x80)\r
+\r
+#define HID_USAGE_GENERIC_X ((USAGE) 0x30)\r
+#define HID_USAGE_GENERIC_Y ((USAGE) 0x31)\r
+#define HID_USAGE_GENERIC_Z ((USAGE) 0x32)\r
+#define HID_USAGE_GENERIC_RX ((USAGE) 0x33)\r
+#define HID_USAGE_GENERIC_RY ((USAGE) 0x34)\r
+#define HID_USAGE_GENERIC_RZ ((USAGE) 0x35)\r
+#define HID_USAGE_GENERIC_SLIDER ((USAGE) 0x36)\r
+#define HID_USAGE_GENERIC_DIAL ((USAGE) 0x37)\r
+#define HID_USAGE_GENERIC_WHEEL ((USAGE) 0x38)\r
+#define HID_USAGE_GENERIC_HATSWITCH ((USAGE) 0x39)\r
+#define HID_USAGE_GENERIC_COUNTED_BUFFER ((USAGE) 0x3A)\r
+#define HID_USAGE_GENERIC_BYTE_COUNT ((USAGE) 0x3B)\r
+#define HID_USAGE_GENERIC_MOTION_WAKEUP ((USAGE) 0x3C)\r
+#define HID_USAGE_GENERIC_VX ((USAGE) 0x40)\r
+#define HID_USAGE_GENERIC_VY ((USAGE) 0x41)\r
+#define HID_USAGE_GENERIC_VZ ((USAGE) 0x42)\r
+#define HID_USAGE_GENERIC_VBRX ((USAGE) 0x43)\r
+#define HID_USAGE_GENERIC_VBRY ((USAGE) 0x44)\r
+#define HID_USAGE_GENERIC_VBRZ ((USAGE) 0x45)\r
+#define HID_USAGE_GENERIC_VNO ((USAGE) 0x46)\r
+#define HID_USAGE_GENERIC_SYSCTL_POWER ((USAGE) 0x81)\r
+#define HID_USAGE_GENERIC_SYSCTL_SLEEP ((USAGE) 0x82)\r
+#define HID_USAGE_GENERIC_SYSCTL_WAKE ((USAGE) 0x83)\r
+#define HID_USAGE_GENERIC_SYSCTL_CONTEXT_MENU ((USAGE) 0x84)\r
+#define HID_USAGE_GENERIC_SYSCTL_MAIN_MENU ((USAGE) 0x85)\r
+#define HID_USAGE_GENERIC_SYSCTL_APP_MENU ((USAGE) 0x86)\r
+#define HID_USAGE_GENERIC_SYSCTL_HELP_MENU ((USAGE) 0x87)\r
+#define HID_USAGE_GENERIC_SYSCTL_MENU_EXIT ((USAGE) 0x88)\r
+#define HID_USAGE_GENERIC_SYSCTL_MENU_SELECT ((USAGE) 0x89)\r
+#define HID_USAGE_GENERIC_SYSCTL_MENU_RIGHT ((USAGE) 0x8A)\r
+#define HID_USAGE_GENERIC_SYSCTL_MENU_LEFT ((USAGE) 0x8B)\r
+#define HID_USAGE_GENERIC_SYSCTL_MENU_UP ((USAGE) 0x8C)\r
+#define HID_USAGE_GENERIC_SYSCTL_MENU_DOWN ((USAGE) 0x8D)\r
+\r
+//\r
+// Usages from Simulation Controls Page (0x02)\r
+//\r
+\r
+#define HID_USAGE_SIMULATION_RUDDER ((USAGE) 0xBA)\r
+#define HID_USAGE_SIMULATION_THROTTLE ((USAGE) 0xBB)\r
+\r
+//\r
+// Virtual Reality Controls Page (0x03)\r
+//\r
+\r
+\r
+//\r
+// Sport Controls Page (0x04)\r
+//\r
+\r
+\r
+//\r
+// Game Controls Page (0x05)\r
+//\r
+\r
+\r
+//\r
+// Keyboard/Keypad Page (0x07)\r
+//\r
+\r
+ // Error "keys"\r
+#define HID_USAGE_KEYBOARD_NOEVENT ((USAGE) 0x00)\r
+#define HID_USAGE_KEYBOARD_ROLLOVER ((USAGE) 0x01)\r
+#define HID_USAGE_KEYBOARD_POSTFAIL ((USAGE) 0x02)\r
+#define HID_USAGE_KEYBOARD_UNDEFINED ((USAGE) 0x03)\r
+\r
+ // Letters\r
+#define HID_USAGE_KEYBOARD_aA ((USAGE) 0x04)\r
+#define HID_USAGE_KEYBOARD_zZ ((USAGE) 0x1D)\r
+ // Numbers\r
+#define HID_USAGE_KEYBOARD_ONE ((USAGE) 0x1E)\r
+#define HID_USAGE_KEYBOARD_ZERO ((USAGE) 0x27)\r
+ // Modifier Keys\r
+#define HID_USAGE_KEYBOARD_LCTRL ((USAGE) 0xE0)\r
+#define HID_USAGE_KEYBOARD_LSHFT ((USAGE) 0xE1)\r
+#define HID_USAGE_KEYBOARD_LALT ((USAGE) 0xE2)\r
+#define HID_USAGE_KEYBOARD_LGUI ((USAGE) 0xE3)\r
+#define HID_USAGE_KEYBOARD_RCTRL ((USAGE) 0xE4)\r
+#define HID_USAGE_KEYBOARD_RSHFT ((USAGE) 0xE5)\r
+#define HID_USAGE_KEYBOARD_RALT ((USAGE) 0xE6)\r
+#define HID_USAGE_KEYBOARD_RGUI ((USAGE) 0xE7)\r
+#define HID_USAGE_KEYBOARD_SCROLL_LOCK ((USAGE) 0x47)\r
+#define HID_USAGE_KEYBOARD_NUM_LOCK ((USAGE) 0x53)\r
+#define HID_USAGE_KEYBOARD_CAPS_LOCK ((USAGE) 0x39)\r
+ // Funtion keys\r
+#define HID_USAGE_KEYBOARD_F1 ((USAGE) 0x3A)\r
+#define HID_USAGE_KEYBOARD_F12 ((USAGE) 0x45)\r
+\r
+#define HID_USAGE_KEYBOARD_RETURN ((USAGE) 0x28)\r
+#define HID_USAGE_KEYBOARD_ESCAPE ((USAGE) 0x29)\r
+#define HID_USAGE_KEYBOARD_DELETE ((USAGE) 0x2A)\r
+\r
+#define HID_USAGE_KEYBOARD_PRINT_SCREEN ((USAGE) 0x46)\r
+\r
+// and hundreds more...\r
+\r
+//\r
+// LED Page (0x08)\r
+//\r
+\r
+#define HID_USAGE_LED_NUM_LOCK ((USAGE) 0x01)\r
+#define HID_USAGE_LED_CAPS_LOCK ((USAGE) 0x02)\r
+#define HID_USAGE_LED_SCROLL_LOCK ((USAGE) 0x03)\r
+#define HID_USAGE_LED_COMPOSE ((USAGE) 0x04)\r
+#define HID_USAGE_LED_KANA ((USAGE) 0x05)\r
+#define HID_USAGE_LED_POWER ((USAGE) 0x06)\r
+#define HID_USAGE_LED_SHIFT ((USAGE) 0x07)\r
+#define HID_USAGE_LED_DO_NOT_DISTURB ((USAGE) 0x08)\r
+#define HID_USAGE_LED_MUTE ((USAGE) 0x09)\r
+#define HID_USAGE_LED_TONE_ENABLE ((USAGE) 0x0A)\r
+#define HID_USAGE_LED_HIGH_CUT_FILTER ((USAGE) 0x0B)\r
+#define HID_USAGE_LED_LOW_CUT_FILTER ((USAGE) 0x0C)\r
+#define HID_USAGE_LED_EQUALIZER_ENABLE ((USAGE) 0x0D)\r
+#define HID_USAGE_LED_SOUND_FIELD_ON ((USAGE) 0x0E)\r
+#define HID_USAGE_LED_SURROUND_FIELD_ON ((USAGE) 0x0F)\r
+#define HID_USAGE_LED_REPEAT ((USAGE) 0x10)\r
+#define HID_USAGE_LED_STEREO ((USAGE) 0x11)\r
+#define HID_USAGE_LED_SAMPLING_RATE_DETECT ((USAGE) 0x12)\r
+#define HID_USAGE_LED_SPINNING ((USAGE) 0x13)\r
+#define HID_USAGE_LED_CAV ((USAGE) 0x14)\r
+#define HID_USAGE_LED_CLV ((USAGE) 0x15)\r
+#define HID_USAGE_LED_RECORDING_FORMAT_DET ((USAGE) 0x16)\r
+#define HID_USAGE_LED_OFF_HOOK ((USAGE) 0x17)\r
+#define HID_USAGE_LED_RING ((USAGE) 0x18)\r
+#define HID_USAGE_LED_MESSAGE_WAITING ((USAGE) 0x19)\r
+#define HID_USAGE_LED_DATA_MODE ((USAGE) 0x1A)\r
+#define HID_USAGE_LED_BATTERY_OPERATION ((USAGE) 0x1B)\r
+#define HID_USAGE_LED_BATTERY_OK ((USAGE) 0x1C)\r
+#define HID_USAGE_LED_BATTERY_LOW ((USAGE) 0x1D)\r
+#define HID_USAGE_LED_SPEAKER ((USAGE) 0x1E)\r
+#define HID_USAGE_LED_HEAD_SET ((USAGE) 0x1F)\r
+#define HID_USAGE_LED_HOLD ((USAGE) 0x20)\r
+#define HID_USAGE_LED_MICROPHONE ((USAGE) 0x21)\r
+#define HID_USAGE_LED_COVERAGE ((USAGE) 0x22)\r
+#define HID_USAGE_LED_NIGHT_MODE ((USAGE) 0x23)\r
+#define HID_USAGE_LED_SEND_CALLS ((USAGE) 0x24)\r
+#define HID_USAGE_LED_CALL_PICKUP ((USAGE) 0x25)\r
+#define HID_USAGE_LED_CONFERENCE ((USAGE) 0x26)\r
+#define HID_USAGE_LED_STAND_BY ((USAGE) 0x27)\r
+#define HID_USAGE_LED_CAMERA_ON ((USAGE) 0x28)\r
+#define HID_USAGE_LED_CAMERA_OFF ((USAGE) 0x29)\r
+#define HID_USAGE_LED_ON_LINE ((USAGE) 0x2A)\r
+#define HID_USAGE_LED_OFF_LINE ((USAGE) 0x2B)\r
+#define HID_USAGE_LED_BUSY ((USAGE) 0x2C)\r
+#define HID_USAGE_LED_READY ((USAGE) 0x2D)\r
+#define HID_USAGE_LED_PAPER_OUT ((USAGE) 0x2E)\r
+#define HID_USAGE_LED_PAPER_JAM ((USAGE) 0x2F)\r
+#define HID_USAGE_LED_REMOTE ((USAGE) 0x30)\r
+#define HID_USAGE_LED_FORWARD ((USAGE) 0x31)\r
+#define HID_USAGE_LED_REVERSE ((USAGE) 0x32)\r
+#define HID_USAGE_LED_STOP ((USAGE) 0x33)\r
+#define HID_USAGE_LED_REWIND ((USAGE) 0x34)\r
+#define HID_USAGE_LED_FAST_FORWARD ((USAGE) 0x35)\r
+#define HID_USAGE_LED_PLAY ((USAGE) 0x36)\r
+#define HID_USAGE_LED_PAUSE ((USAGE) 0x37)\r
+#define HID_USAGE_LED_RECORD ((USAGE) 0x38)\r
+#define HID_USAGE_LED_ERROR ((USAGE) 0x39)\r
+#define HID_USAGE_LED_SELECTED_INDICATOR ((USAGE) 0x3A)\r
+#define HID_USAGE_LED_IN_USE_INDICATOR ((USAGE) 0x3B)\r
+#define HID_USAGE_LED_MULTI_MODE_INDICATOR ((USAGE) 0x3C)\r
+#define HID_USAGE_LED_INDICATOR_ON ((USAGE) 0x3D)\r
+#define HID_USAGE_LED_INDICATOR_FLASH ((USAGE) 0x3E)\r
+#define HID_USAGE_LED_INDICATOR_SLOW_BLINK ((USAGE) 0x3F)\r
+#define HID_USAGE_LED_INDICATOR_FAST_BLINK ((USAGE) 0x40)\r
+#define HID_USAGE_LED_INDICATOR_OFF ((USAGE) 0x41)\r
+#define HID_USAGE_LED_FLASH_ON_TIME ((USAGE) 0x42)\r
+#define HID_USAGE_LED_SLOW_BLINK_ON_TIME ((USAGE) 0x43)\r
+#define HID_USAGE_LED_SLOW_BLINK_OFF_TIME ((USAGE) 0x44)\r
+#define HID_USAGE_LED_FAST_BLINK_ON_TIME ((USAGE) 0x45)\r
+#define HID_USAGE_LED_FAST_BLINK_OFF_TIME ((USAGE) 0x46)\r
+#define HID_USAGE_LED_INDICATOR_COLOR ((USAGE) 0x47)\r
+#define HID_USAGE_LED_RED ((USAGE) 0x48)\r
+#define HID_USAGE_LED_GREEN ((USAGE) 0x49)\r
+#define HID_USAGE_LED_AMBER ((USAGE) 0x4A)\r
+#define HID_USAGE_LED_GENERIC_INDICATOR ((USAGE) 0x3B)\r
+\r
+//\r
+// Button Page (0x09)\r
+//\r
+// There is no need to label these usages.\r
+//\r
+\r
+\r
+//\r
+// Ordinal Page (0x0A)\r
+//\r
+// There is no need to label these usages.\r
+//\r
+\r
+\r
+//\r
+// Telephony Device Page (0x0B)\r
+//\r
+\r
+#define HID_USAGE_TELEPHONY_PHONE ((USAGE) 0x01)\r
+#define HID_USAGE_TELEPHONY_ANSWERING_MACHINE ((USAGE) 0x02)\r
+#define HID_USAGE_TELEPHONY_MESSAGE_CONTROLS ((USAGE) 0x03)\r
+#define HID_USAGE_TELEPHONY_HANDSET ((USAGE) 0x04)\r
+#define HID_USAGE_TELEPHONY_HEADSET ((USAGE) 0x05)\r
+#define HID_USAGE_TELEPHONY_KEYPAD ((USAGE) 0x06)\r
+#define HID_USAGE_TELEPHONY_PROGRAMMABLE_BUTTON ((USAGE) 0x07)\r
+\r
+//\r
+// and others...\r
+//\r
+\r
+\r
+#endif\r
--- /dev/null
+#include <windows.h>\r
+#include <setupapi.h>\r
+#include <stdio.h>\r
+#include <ctype.h>\r
+#include <stdlib.h>\r
+extern "C" {\r
+#include "include/hidsdi.h"\r
+#include "include/hidpi.h"\r
+}\r
+\r
+#include "prox.h"\r
+\r
+#define OUR_VID 0x9ac4\r
+#define OUR_PID 0x4b8f\r
+#define bzero(b,len) (memset((b), '\0', (len)), (void) 0)\r
+\r
+int offline = 0;\r
+HANDLE UsbHandle;\r
+\r
+static void ShowError(void)\r
+{\r
+ char buf[1024];\r
+ FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,\r
+ buf, sizeof(buf), NULL);\r
+ printf("ERROR: %s", buf);\r
+}\r
+\r
+static BOOL UsbConnect(void)\r
+{\r
+ typedef void (__stdcall *GetGuidProc)(GUID *);\r
+ typedef BOOLEAN (__stdcall *GetAttrProc)(HANDLE, HIDD_ATTRIBUTES *);\r
+ typedef BOOLEAN (__stdcall *GetPreparsedProc)(HANDLE,\r
+ PHIDP_PREPARSED_DATA *);\r
+ typedef NTSTATUS (__stdcall *GetCapsProc)(PHIDP_PREPARSED_DATA, PHIDP_CAPS);\r
+ GetGuidProc getGuid;\r
+ GetAttrProc getAttr;\r
+ GetPreparsedProc getPreparsed;\r
+ GetCapsProc getCaps;\r
+\r
+ HMODULE h = LoadLibrary("hid.dll");\r
+ getGuid = (GetGuidProc)GetProcAddress(h, "HidD_GetHidGuid");\r
+ getAttr = (GetAttrProc)GetProcAddress(h, "HidD_GetAttributes");\r
+ getPreparsed = (GetPreparsedProc)GetProcAddress(h, "HidD_GetPreparsedData");\r
+ getCaps = (GetCapsProc)GetProcAddress(h, "HidP_GetCaps");\r
+\r
+ GUID hidGuid;\r
+ getGuid(&hidGuid);\r
+\r
+ HDEVINFO devInfo;\r
+ devInfo = SetupDiGetClassDevs(&hidGuid, NULL, NULL,\r
+ DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);\r
+\r
+ SP_DEVICE_INTERFACE_DATA devInfoData;\r
+ devInfoData.cbSize = sizeof(devInfoData);\r
+\r
+ int i;\r
+ for(i = 0;; i++) {\r
+ if(!SetupDiEnumDeviceInterfaces(devInfo, 0, &hidGuid, i, &devInfoData))\r
+ {\r
+ if(GetLastError() != ERROR_NO_MORE_ITEMS) {\r
+// printf("SetupDiEnumDeviceInterfaces failed\n");\r
+ }\r
+// printf("done list\n");\r
+ SetupDiDestroyDeviceInfoList(devInfo);\r
+ return FALSE;\r
+ }\r
+\r
+// printf("item %d:\n", i);\r
+\r
+ DWORD sizeReqd = 0;\r
+ if(!SetupDiGetDeviceInterfaceDetail(devInfo, &devInfoData,\r
+ NULL, 0, &sizeReqd, NULL))\r
+ {\r
+ if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) {\r
+// printf("SetupDiGetDeviceInterfaceDetail (0) failed\n");\r
+ continue;\r
+ }\r
+ }\r
+\r
+ SP_DEVICE_INTERFACE_DETAIL_DATA *devInfoDetailData =\r
+ (SP_DEVICE_INTERFACE_DETAIL_DATA *)malloc(sizeReqd);\r
+ devInfoDetailData->cbSize = sizeof(*devInfoDetailData);\r
+\r
+ if(!SetupDiGetDeviceInterfaceDetail(devInfo, &devInfoData,\r
+ devInfoDetailData, 87, NULL, NULL))\r
+ {\r
+// printf("SetupDiGetDeviceInterfaceDetail (1) failed\n");\r
+ continue;\r
+ }\r
+\r
+ char *path = devInfoDetailData->DevicePath;\r
+\r
+ UsbHandle = CreateFile(path, /*GENERIC_READ |*/ GENERIC_WRITE,\r
+ FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,\r
+ FILE_FLAG_OVERLAPPED, NULL);\r
+\r
+ if(UsbHandle == INVALID_HANDLE_VALUE) {\r
+ ShowError();\r
+// printf("CreateFile failed: for '%s'\n", path);\r
+ continue;\r
+ }\r
+\r
+ HIDD_ATTRIBUTES attr;\r
+ attr.Size = sizeof(attr);\r
+ if(!getAttr(UsbHandle, &attr)) {\r
+ ShowError();\r
+// printf("HidD_GetAttributes failed\n");\r
+ continue;\r
+ }\r
+\r
+// printf("VID: %04x PID %04x\n", attr.VendorID, attr.ProductID);\r
+\r
+ if(attr.VendorID != OUR_VID || attr.ProductID != OUR_PID) {\r
+ CloseHandle(UsbHandle);\r
+// printf(" nope, not us\n");\r
+ continue;\r
+ }\r
+\r
+// printf ("got it!\n");\r
+ CloseHandle(UsbHandle);\r
+\r
+ UsbHandle = CreateFile(path, GENERIC_READ | GENERIC_WRITE,\r
+ FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,\r
+ FILE_FLAG_OVERLAPPED, NULL);\r
+\r
+ if(UsbHandle == INVALID_HANDLE_VALUE) {\r
+ ShowError();\r
+// printf("Error, couldn't open our own handle as desired.\n");\r
+ return FALSE;\r
+ }\r
+\r
+ PHIDP_PREPARSED_DATA pp;\r
+ getPreparsed(UsbHandle, &pp);\r
+ HIDP_CAPS caps;\r
+\r
+ if(getCaps(pp, &caps) != HIDP_STATUS_SUCCESS) {\r
+// printf("getcaps failed\n");\r
+ return FALSE;\r
+ }\r
+\r
+// printf("input/out report %d/%d\n", caps.InputReportByteLength,\r
+// caps.OutputReportByteLength);\r
+\r
+\r
+ return TRUE;\r
+ }\r
+ return FALSE;\r
+}\r
+\r
+BOOL ReceiveCommandPoll(UsbCommand *c)\r
+{\r
+ static BOOL ReadInProgress = FALSE;\r
+ static OVERLAPPED Ov;\r
+ static BYTE Buf[65];\r
+ static DWORD HaveRead;\r
+\r
+ if(!ReadInProgress) {\r
+ memset(&Ov, 0, sizeof(Ov));\r
+ ReadFile(UsbHandle, Buf, 65, &HaveRead, &Ov);\r
+ if(GetLastError() != ERROR_IO_PENDING) {\r
+ ShowError();\r
+ exit(-1);\r
+ }\r
+ ReadInProgress = TRUE;\r
+ }\r
+\r
+ if(HasOverlappedIoCompleted(&Ov)) {\r
+ ReadInProgress = FALSE;\r
+\r
+ if(!GetOverlappedResult(UsbHandle, &Ov, &HaveRead, FALSE)) {\r
+ ShowError();\r
+ exit(-1);\r
+ }\r
+\r
+ memcpy(c, Buf+1, 64);\r
+\r
+ return TRUE;\r
+ } else {\r
+ return FALSE;\r
+ }\r
+}\r
+\r
+void ReceiveCommand(UsbCommand *c)\r
+{\r
+ while(!ReceiveCommandPoll(c)) {\r
+ Sleep(0);\r
+ }\r
+}\r
+\r
+void SendCommand(UsbCommand *c, BOOL wantAck)\r
+{\r
+ BYTE buf[65];\r
+ buf[0] = 0;\r
+ memcpy(buf+1, c, 64);\r
+\r
+ DWORD written;\r
+ OVERLAPPED ov;\r
+\r
+ memset(&ov, 0, sizeof(ov));\r
+ WriteFile(UsbHandle, buf, 65, &written, &ov);\r
+ if(GetLastError() != ERROR_IO_PENDING) {\r
+ ShowError();\r
+ exit(-1);\r
+ }\r
+\r
+ while(!HasOverlappedIoCompleted(&ov)) {\r
+ Sleep(0);\r
+ }\r
+\r
+ if(!GetOverlappedResult(UsbHandle, &ov, &written, FALSE)) {\r
+ ShowError();\r
+ exit(-1);\r
+ }\r
+\r
+ if(wantAck) {\r
+ UsbCommand ack;\r
+ ReceiveCommand(&ack);\r
+ if(ack.cmd != CMD_ACK) {\r
+ printf("bad ACK\n");\r
+ exit(-1);\r
+ }\r
+ }\r
+}\r
+\r
+static DWORD ExpectedAddr;\r
+static BYTE QueuedToSend[256];\r
+static BOOL AllWritten;\r
+#define PHYSICAL_FLASH_START 0x100000\r
+\r
+struct partition {\r
+ int start;\r
+ int end;\r
+ int precious;\r
+ const char *name;\r
+};\r
+struct partition partitions[] = {\r
+ {0x100000, 0x102000, 1, "bootrom"},\r
+ {0x102000, 0x110000, 0, "fpga"},\r
+ {0x110000, 0x140000, 0, "os"},\r
+};\r
+\r
+/* If translate is set, subtract PHYSICAL_FLASH_START to translate for old\r
+ * bootroms.\r
+ */\r
+static void FlushPrevious(int translate)\r
+{\r
+ UsbCommand c;\r
+ memset(&c, 0, sizeof(c));\r
+\r
+// printf("expected = %08x flush, ", ExpectedAddr);\r
+\r
+ int i;\r
+ for(i = 0; i < 240; i += 48) {\r
+ c.cmd = CMD_SETUP_WRITE;\r
+ memcpy(c.d.asBytes, QueuedToSend+i, 48);\r
+ c.ext1 = (i/4);\r
+ SendCommand(&c, TRUE);\r
+ }\r
+\r
+ c.cmd = CMD_FINISH_WRITE;\r
+ c.ext1 = (ExpectedAddr-1) & (~255);\r
+ if(translate) {\r
+ c.ext1 -= PHYSICAL_FLASH_START;\r
+ }\r
+ printf("Flashing address: %08x\r", c.ext1);\r
+ memcpy(c.d.asBytes, QueuedToSend+240, 16);\r
+ SendCommand(&c, TRUE);\r
+\r
+ AllWritten = TRUE;\r
+}\r
+\r
+/* Where must be between start_addr (inclusive) and end_addr (exclusive).\r
+ */\r
+static void GotByte(int where, BYTE which, int start_addr, int end_addr, int translate)\r
+{\r
+ AllWritten = FALSE;\r
+\r
+ if(where < start_addr || where >= end_addr) {\r
+ printf("bad: got byte at %08x, outside of range %08x-%08x\n", where, start_addr, end_addr);\r
+ exit(-1);\r
+ }\r
+\r
+ if(where != ExpectedAddr) {\r
+ printf("bad: got at %08x, expected at %08x\n", where, ExpectedAddr);\r
+ exit(-1);\r
+ }\r
+ QueuedToSend[where & 255] = which;\r
+ ExpectedAddr++;\r
+\r
+ if((where & 255) == 255) {\r
+ // we have completed a full page\r
+ FlushPrevious(translate);\r
+ }\r
+}\r
+\r
+static int HexVal(int c)\r
+{\r
+ c = tolower(c);\r
+ if(c >= '0' && c <= '9') {\r
+ return c - '0';\r
+ } else if(c >= 'a' && c <= 'f') {\r
+ return (c - 'a') + 10;\r
+ } else {\r
+ printf("bad hex digit '%c'\n", c);\r
+ exit(-1);\r
+ }\r
+}\r
+\r
+static BYTE HexByte(char *s)\r
+{\r
+ return (HexVal(s[0]) << 4) | HexVal(s[1]);\r
+}\r
+\r
+static void LoadFlashFromSRecords(const char *file, int start_addr, int end_addr, int translate)\r
+{\r
+ ExpectedAddr = start_addr;\r
+\r
+ FILE *f = fopen(file, "r");\r
+ if(!f) {\r
+ printf("couldn't open file\n");\r
+ exit(-1);\r
+ }\r
+\r
+ char line[512];\r
+ while(fgets(line, sizeof(line), f)) {\r
+ if(memcmp(line, "S3", 2)==0) {\r
+ char *s = line + 2;\r
+ int len = HexByte(s) - 5;\r
+ s += 2;\r
+\r
+ char addrStr[9];\r
+ memcpy(addrStr, s, 8);\r
+ addrStr[8] = '\0';\r
+ DWORD addr;\r
+ sscanf(addrStr, "%x", &addr);\r
+ s += 8;\r
+\r
+ /* Accept files that are located at PHYSICAL_FLASH_START, and files that are located at 0 */\r
+ if(addr < PHYSICAL_FLASH_START)\r
+ addr += PHYSICAL_FLASH_START;\r
+\r
+ int i;\r
+ for(i = 0; i < len; i++) {\r
+ while((addr+i) > ExpectedAddr) {\r
+ GotByte(ExpectedAddr, 0xff, start_addr, end_addr, translate);\r
+ }\r
+ GotByte(addr+i, HexByte(s), start_addr, end_addr, translate);\r
+ s += 2;\r
+ }\r
+ }\r
+ }\r
+\r
+ if(!AllWritten) FlushPrevious(translate);\r
+\r
+ fclose(f);\r
+ printf("\ndone.\n");\r
+}\r
+\r
+static int PrepareFlash(struct partition *p, const char *filename, unsigned int state)\r
+{\r
+ int translate = 0;\r
+ if(state & DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH) {\r
+ UsbCommand c;\r
+ c.cmd = CMD_START_FLASH;\r
+ c.ext1 = p->start;\r
+ c.ext2 = p->end;\r
+\r
+ /* Only send magic when flashing bootrom */\r
+ if(p->precious) {\r
+ c.ext3 = START_FLASH_MAGIC;\r
+ } else {\r
+ c.ext3 = 0;\r
+ }\r
+ SendCommand(&c, TRUE);\r
+ translate = 0;\r
+ } else {\r
+ fprintf(stderr, "Warning: Your bootloader does not understand the new START_FLASH command\n");\r
+ fprintf(stderr, " It is recommended that you update your bootloader\n\n");\r
+ translate = 1;\r
+ }\r
+\r
+ LoadFlashFromSRecords(filename, p->start, p->end, translate);\r
+ return 1;\r
+}\r
+\r
+static unsigned int GetProxmarkState(void)\r
+{\r
+ unsigned int state = 0;\r
+\r
+ UsbCommand c;\r
+ c.cmd = CMD_DEVICE_INFO;\r
+ SendCommand(&c, FALSE);\r
+\r
+ UsbCommand resp;\r
+ ReceiveCommand(&resp);\r
+ /* Three cases:\r
+ * 1. The old bootrom code will ignore CMD_DEVICE_INFO, but respond with an ACK\r
+ * 2. The old os code will respond with CMD_DEBUG_PRINT_STRING and "unknown command"\r
+ * 3. The new bootrom and os codes will respond with CMD_DEVICE_INFO and flags\r
+ */\r
+\r
+ switch(resp.cmd) {\r
+ case CMD_ACK:\r
+ state = DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM;\r
+ break;\r
+ case CMD_DEBUG_PRINT_STRING:\r
+ state = DEVICE_INFO_FLAG_CURRENT_MODE_OS;\r
+ break;\r
+ case CMD_DEVICE_INFO:\r
+ state = resp.ext1;\r
+ break;\r
+ default:\r
+ fprintf(stderr, "Couldn't get proxmark state, bad response type: 0x%04X\n", resp.cmd);\r
+ exit(-1);\r
+ break;\r
+ }\r
+\r
+#if 0\r
+ if(state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) printf("New bootrom present\n");\r
+ if(state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) printf("New osimage present\n");\r
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) printf("Currently in bootrom\n");\r
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) printf("Currently in OS\n");\r
+#endif\r
+\r
+ return state;\r
+}\r
+\r
+static unsigned int EnterFlashState(void)\r
+{\r
+ unsigned int state = GetProxmarkState();\r
+\r
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) {\r
+ /* Already in flash state, we're done. */\r
+ return state;\r
+ }\r
+\r
+ if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) {\r
+ fprintf(stderr,"Entering flash-mode...\n");\r
+ UsbCommand c;\r
+ bzero(&c, sizeof(c));\r
+\r
+ if( (state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) && (state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) ) {\r
+ /* New style handover: Send CMD_START_FLASH, which will reset the board and\r
+ * enter the bootrom on the next boot.\r
+ */\r
+ c.cmd = CMD_START_FLASH;\r
+ SendCommand(&c, FALSE);\r
+ fprintf(stderr,"(You don't have to do anything. Press and release the button only if you want to abort)\n");\r
+ fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");\r
+ } else {\r
+ /* Old style handover: Ask the user to press the button, then reset the board */\r
+ c.cmd = CMD_HARDWARE_RESET;\r
+ SendCommand(&c, FALSE);\r
+ fprintf(stderr,"(Press and hold down button NOW if your bootloader requires it)\n");\r
+ fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");\r
+ }\r
+\r
+\r
+ Sleep(1000);\r
+\r
+ while(!UsbConnect()) { Sleep(1000); }\r
+ fprintf(stderr,"Found.\n");\r
+\r
+ return GetProxmarkState();\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+static void usage(char **argv)\r
+{\r
+ int i;\r
+ printf("Usage: %s gui\n", argv[0]);\r
+ printf(" %s offline\n", argv[0]);\r
+ printf(" %s areas file.s19\n", argv[0]);\r
+ printf(" Known areas are:");\r
+ for(i=0; i<(sizeof(partitions)/sizeof(partitions[0])); i++) {\r
+ fprintf(stderr, " %s", partitions[i].name);\r
+ }\r
+\r
+ printf("\n");\r
+}\r
+\r
+/* On first call, have *offset = -1, *length = 0; */\r
+static int find_next_area(char *str, int *offset, int *length)\r
+{\r
+ if(*str == '\0') return 0;\r
+ if((*offset >= 0) && str[*offset + *length] == '\0') return 0;\r
+ *offset += 1 + *length;\r
+\r
+ char *next_comma = strchr(str + *offset, ',');\r
+ if(next_comma == NULL) {\r
+ *length = strlen(str) - *offset;\r
+ } else {\r
+ *length = next_comma-(str+*offset);\r
+ }\r
+ return 1;\r
+}\r
+\r
+int main(int argc, char **argv)\r
+{\r
+ int i = 0;\r
+\r
+ if(argc < 2) {\r
+ usage(argv);\r
+ exit(-1);\r
+ }\r
+\r
+ // Only do this if NOT in offline mode\r
+ if (strcmp(argv[1], "offline"))\r
+ {\r
+ for(;;) {\r
+ if(UsbConnect()) {\r
+ break;\r
+ }\r
+ if(i == 0) {\r
+ printf("...no device connected, polling for it now\n");\r
+ }\r
+ if(i > 50000) {\r
+ printf("Could not connect to USB device; exiting.\n");\r
+ return -1;\r
+ }\r
+ i++;\r
+ Sleep(5);\r
+ }\r
+ }\r
+\r
+ if(strcmp(argv[1], "gui")==0) {\r
+ ShowGui();\r
+ } else if(strcmp(argv[1], "offline")==0) {\r
+ offline = 1;\r
+ ShowGui();\r
+ }\r
+\r
+ /* Count area arguments */\r
+ int areas = 0, offset=-1, length=0;\r
+ while(find_next_area(argv[1], &offset, &length)) areas++;\r
+\r
+ if(areas != argc - 2) {\r
+ usage(argv);\r
+ exit(-1);\r
+ }\r
+\r
+ unsigned int state = EnterFlashState();\r
+\r
+ if( !(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) ) {\r
+ fprintf(stderr, "Proxmark would not enter flash state, abort\n");\r
+ exit(-1);\r
+ }\r
+\r
+ offset=-1; length=0;\r
+ int current_area = 0;\r
+ while(find_next_area(argv[1], &offset, &length)) {\r
+ int i;\r
+ struct partition *p = NULL;\r
+ for(i=0; i<sizeof(partitions)/sizeof(partitions[0]); i++) {\r
+ if(strncmp(partitions[i].name, argv[1] + offset, length) == 0) {\r
+ /* Check if the name matches the bootrom partition, and if so, require "bootrom" to\r
+ * be written in full. The other names may be abbreviated.\r
+ */\r
+ if(!partitions[i].precious || (strlen(partitions[i].name) == length)) {\r
+ p = &partitions[i];\r
+ }\r
+ break;\r
+ }\r
+ }\r
+\r
+ if(p == NULL) {\r
+ fprintf(stderr, "Warning: area name '");\r
+ fwrite(argv[1]+offset, length, 1, stderr);\r
+ fprintf(stderr, "' unknown, ignored\n");\r
+ } else {\r
+ fprintf(stderr, "Flashing %s from %s\n", p->name, argv[2+current_area]);\r
+ PrepareFlash(p, argv[2+current_area], state);\r
+ }\r
+ current_area++;\r
+ }\r
+\r
+ return 0;\r
+}\r
--- /dev/null
+#ifndef __PROX_H\r
+#define __PROX_H\r
+\r
+#include "../include/usb_cmd.h"\r
+\r
+// prox.cpp\r
+void ReceiveCommand(UsbCommand *c);\r
+BOOL ReceiveCommandPoll(UsbCommand *c);\r
+void SendCommand(UsbCommand *c, BOOL wantAck);\r
+\r
+// gui.cpp\r
+void ShowGui();\r
+void HideGraphWindow(void);\r
+void ShowGraphWindow(void);\r
+void RepaintGraphWindow(void);\r
+void PrintToScrollback(char *fmt, ...);\r
+#define MAX_GRAPH_TRACE_LEN (1024*128)\r
+extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];\r
+extern int GraphTraceLen;\r
+extern double CursorScaleFactor;\r
+extern int PlotGridX, PlotGridY;\r
+extern int CommandFinished;\r
+extern int offline;\r
+\r
+// command.cpp\r
+static void CmdBuffClear(char *str);\r
+static void GetFromBigBuf(BYTE *dest, int bytes);\r
+static void CmdReset(char *str);\r
+static void CmdQuit(char *str);\r
+static void CmdEM410xread(char *str);\r
+static void CmdEM410xwatch(char *str);\r
+static void ChkBitstream(char *str);\r
+int GetClock(char *str, int peak);\r
+static void CmdHIDdemodFSK(char *str);\r
+static void Cmdmanchestermod(char *str);\r
+static void CmdTune(char *str);\r
+static void CmdHi15read(char *str);\r
+static void CmdHi14read(char *str);\r
+static void CmdSri512read(char *str);\r
+static void CmdHi14areader(char *str);\r
+static void CmdHi15reader(char *str);\r
+static void CmdHi15tag(char *str);\r
+static void CmdHi14read_sim(char *str);\r
+static void CmdHi14readt(char *str);\r
+static void CmdHisimlisten(char *str);\r
+static void CmdReadmem(char *str);\r
+static void CmdHi14sim(char *str);\r
+static void CmdHi14asim(char *str);\r
+static void CmdHi14snoop(char *str);\r
+static void CmdHi14asnoop(char *str);\r
+static void CmdFPGAOff(char *str);\r
+int CmdClearGraph(int redraw);\r
+static void CmdAppendGraph(int redraw, int clock, int bit);\r
+static void CmdEM410xsim(char *str);\r
+static void CmdLosim(char *str);\r
+static void CmdLoCommandRead(char *str);\r
+static void CmdLoread(char *str);\r
+static void CmdLosamples(char *str);\r
+static void CmdBitsamples(char *str);\r
+static void CmdHisamples(char *str);\r
+static int CmdHisamplest(char *str, int nrlow);\r
+static void CmdHexsamples(char *str);\r
+static void CmdHisampless(char *str);\r
+static WORD Iso15693Crc(BYTE *v, int n);\r
+static void CmdHi14bdemod(char *str);\r
+static void CmdHi14list(char *str);\r
+static void CmdHi14alist(char *str);\r
+static void CmdHi15demod(char *str);\r
+static void CmdTiread(char *str);\r
+static void CmdTibits(char *str);\r
+static void CmdTidemod(char *cmdline);\r
+static void CmdNorm(char *str);\r
+static void CmdDec(char *str);\r
+static void CmdHpf(char *str);\r
+static void CmdZerocrossings(char *str);\r
+static void CmdLtrim(char *str);\r
+static void CmdAutoCorr(char *str);\r
+static void CmdVchdemod(char *str);\r
+static void CmdIndalademod(char *str);\r
+static void CmdFlexdemod(char *str);\r
+static void Cmdaskdemod(char *str);\r
+static void Cmddetectclockrate(char *str);\r
+int detectclock(int peak);\r
+static void Cmdbitstream(char *str);\r
+static void Cmdmanchesterdemod(char *str);\r
+static void CmdHiddemod(char *str);\r
+static void CmdPlot(char *str);\r
+static void CmdHide(char *str);\r
+static void CmdScale(char *str);\r
+static void CmdSave(char *str);\r
+static void CmdLoad(char *str);\r
+static void CmdHIDsimTAG(char *str);\r
+static void CmdLcdReset(char *str);\r
+static void CmdLcd(char *str);\r
+static void CmdTest(char *str);\r
+static void CmdSetDivisor(char *str);\r
+static void CmdSweepLF(char *str);\r
+void CommandReceived(char *cmd);\r
+void UsbCommandReceived(UsbCommand *c);\r
+\r
+\r
+// cmdline.cpp\r
+void ShowCommandline(void);\r
+void ExecCmd(char *cmd);\r
+//void PrintToScrollback(char *fmt, ...);\r
+\r
+#endif\r
--- /dev/null
+#include "proxgui.h"
+#include "proxguiqt.h"
+
+static ProxGuiQT *gui = NULL;
+
+extern "C" void ShowGraphWindow(void)
+{
+ if (!gui)
+ return;
+
+ gui->ShowGraphWindow();
+}
+
+extern "C" void HideGraphWindow(void)
+{
+ if (!gui)
+ return;
+
+ gui->HideGraphWindow();
+}
+
+extern "C" void RepaintGraphWindow(void)
+{
+ if (!gui)
+ return;
+
+ gui->RepaintGraphWindow();
+}
+
+extern "C" void MainGraphics(void)
+{
+ if (!gui)
+ return;
+
+ gui->MainLoop();
+}
+
+extern "C" void InitGraphics(int argc, char **argv)
+{
+#ifdef Q_WS_X11
+ bool useGUI = getenv("DISPLAY") != 0;
+#else
+ bool useGUI = true;
+#endif
+ if (!useGUI)
+ return;
+
+ gui = new ProxGuiQT(argc, argv);
+}
+
+extern "C" void ExitGraphics(void)
+{
+ if (!gui)
+ return;
+
+ delete gui;
+ gui = NULL;
+}
--- /dev/null
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void ShowGraphWindow(void);
+void HideGraphWindow(void);
+void RepaintGraphWindow(void);
+void MainGraphics(void);
+void InitGraphics(int argc, char **argv);
+void ExitGraphics(void);
+
+#define MAX_GRAPH_TRACE_LEN (1024*128)
+extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];
+extern int GraphTraceLen;
+extern double CursorScaleFactor;
+extern int PlotGridX, PlotGridY;
+extern int CommandFinished;
+extern int offline;
+
+#ifdef __cplusplus
+}
+#endif
--- /dev/null
+#include <iostream>
+#include <QPainterPath>
+#include <QBrush>
+#include <QPen>
+#include <QTimer>
+#include <QCloseEvent>
+#include <QMouseEvent>
+#include <QKeyEvent>
+#include <math.h>
+#include <limits.h>
+#include <stdio.h>
+#include "proxguiqt.h"
+#include "proxgui.h"
+
+void ProxGuiQT::ShowGraphWindow(void)
+{
+ emit ShowGraphWindowSignal();
+}
+
+void ProxGuiQT::RepaintGraphWindow(void)
+{
+ emit RepaintGraphWindowSignal();
+}
+
+void ProxGuiQT::HideGraphWindow(void)
+{
+ emit HideGraphWindowSignal();
+}
+
+void ProxGuiQT::_ShowGraphWindow(void)
+{
+ if(!plotapp)
+ return;
+
+ if (!plotwidget)
+ plotwidget = new ProxWidget();
+
+ plotwidget->show();
+}
+
+void ProxGuiQT::_RepaintGraphWindow(void)
+{
+ if (!plotapp || !plotwidget)
+ return;
+
+ plotwidget->update();
+}
+
+void ProxGuiQT::_HideGraphWindow(void)
+{
+ if (!plotapp || !plotwidget)
+ return;
+
+ plotwidget->hide();
+}
+
+void ProxGuiQT::MainLoop()
+{
+ plotapp = new QApplication(argc, argv);
+
+ connect(this, SIGNAL(ShowGraphWindowSignal()), this, SLOT(_ShowGraphWindow()));
+ connect(this, SIGNAL(RepaintGraphWindowSignal()), this, SLOT(_RepaintGraphWindow()));
+ connect(this, SIGNAL(HideGraphWindowSignal()), this, SLOT(_HideGraphWindow()));
+
+ plotapp->exec();
+}
+
+ProxGuiQT::ProxGuiQT(int argc, char **argv) : plotapp(NULL), plotwidget(NULL),
+ argc(argc), argv(argv)
+{
+}
+
+ProxGuiQT::~ProxGuiQT(void)
+{
+ if (plotwidget) {
+ delete plotwidget;
+ plotwidget = NULL;
+ }
+
+ if (plotapp) {
+ plotapp->quit();
+ delete plotapp;
+ plotapp = NULL;
+ }
+}
+
+void ProxWidget::paintEvent(QPaintEvent *event)
+{
+ QPainter painter(this);
+ QPainterPath penPath, whitePath, greyPath, lightgreyPath, cursorAPath, cursorBPath;
+ QRect r;
+ QBrush brush(QColor(100, 255, 100));
+ QPen pen(QColor(100, 255, 100));
+
+ painter.setFont(QFont("Arial", 10));
+
+ if(GraphStart < 0) {
+ GraphStart = 0;
+ }
+
+ if (CursorAPos > GraphTraceLen)
+ CursorAPos= 0;
+ if(CursorBPos > GraphTraceLen)
+ CursorBPos= 0;
+
+ r = rect();
+
+ painter.fillRect(r, QColor(0, 0, 0));
+
+ whitePath.moveTo(r.left() + 40, r.top());
+ whitePath.lineTo(r.left() + 40, r.bottom());
+
+ int zeroHeight = r.top() + (r.bottom() - r.top()) / 2;
+
+ greyPath.moveTo(r.left(), zeroHeight);
+ greyPath.lineTo(r.right(), zeroHeight);
+ painter.setPen(QColor(100, 100, 100));
+ painter.drawPath(greyPath);
+
+ // plot X and Y grid lines
+ int i;
+ if ((PlotGridX > 0) && ((PlotGridX * GraphPixelsPerPoint) > 1)) {
+ for(i = 40; i < r.right(); i += (int)(PlotGridX * GraphPixelsPerPoint)) {
+ //SelectObject(hdc, GreyPenLite);
+ //MoveToEx(hdc, r.left + i, r.top, NULL);
+ //LineTo(hdc, r.left + i, r.bottom);
+ lightgreyPath.moveTo(r.left()+i,r.top());
+ lightgreyPath.lineTo(r.left()+i,r.bottom());
+ painter.drawPath(lightgreyPath);
+ }
+ }
+ if ((PlotGridY > 0) && ((PlotGridY * GraphPixelsPerPoint) > 1)){
+ for(i = 0; i < ((r.top() + r.bottom())>>1); i += (int)(PlotGridY * GraphPixelsPerPoint)) {
+ lightgreyPath.moveTo(r.left() + 40,zeroHeight + i);
+ lightgreyPath.lineTo(r.right(),zeroHeight + i);
+ painter.drawPath(lightgreyPath);
+ lightgreyPath.moveTo(r.left() + 40,zeroHeight - i);
+ lightgreyPath.lineTo(r.right(),zeroHeight - i);
+ painter.drawPath(lightgreyPath);
+ }
+ }
+
+ int startMax =
+ (GraphTraceLen - (int)((r.right() - r.left() - 40) / GraphPixelsPerPoint));
+ if(startMax < 0) {
+ startMax = 0;
+ }
+ if(GraphStart > startMax) {
+ GraphStart = startMax;
+ }
+
+ int absYMax = 1;
+
+ for(i = GraphStart; ; i++) {
+ if(i >= GraphTraceLen) {
+ break;
+ }
+ if(fabs((double)GraphBuffer[i]) > absYMax) {
+ absYMax = (int)fabs((double)GraphBuffer[i]);
+ }
+ int x = 40 + (int)((i - GraphStart)*GraphPixelsPerPoint);
+ if(x > r.right()) {
+ break;
+ }
+ }
+
+ absYMax = (int)(absYMax*1.2 + 1);
+
+ // number of points that will be plotted
+ int span = (int)((r.right() - r.left()) / GraphPixelsPerPoint);
+ // one label every 100 pixels, let us say
+ int labels = (r.right() - r.left() - 40) / 100;
+ if(labels <= 0) labels = 1;
+ int pointsPerLabel = span / labels;
+ if(pointsPerLabel <= 0) pointsPerLabel = 1;
+
+ int yMin = INT_MAX;
+ int yMax = INT_MIN;
+ int yMean = 0;
+ int n = 0;
+
+ for(i = GraphStart; ; i++) {
+ if(i >= GraphTraceLen) {
+ break;
+ }
+ int x = 40 + (int)((i - GraphStart)*GraphPixelsPerPoint);
+ if(x > r.right() + GraphPixelsPerPoint) {
+ break;
+ }
+
+ int y = GraphBuffer[i];
+ if(y < yMin) {
+ yMin = y;
+ }
+ if(y > yMax) {
+ yMax = y;
+ }
+ yMean += y;
+ n++;
+
+ y = (y * (r.top() - r.bottom()) / (2*absYMax)) + zeroHeight;
+ if(i == GraphStart) {
+ penPath.moveTo(x, y);
+ } else {
+ penPath.lineTo(x, y);
+ }
+
+ if(GraphPixelsPerPoint > 10) {
+ QRect f(QPoint(x - 3, y - 3),QPoint(x + 3, y + 3));
+ painter.fillRect(f, brush);
+ }
+
+ if(((i - GraphStart) % pointsPerLabel == 0) && i != GraphStart) {
+ whitePath.moveTo(x, zeroHeight - 3);
+ whitePath.lineTo(x, zeroHeight + 3);
+
+ char str[100];
+ sprintf(str, "+%d", (i - GraphStart));
+
+ painter.setPen(QColor(255, 255, 255));
+ QRect size;
+ QFontMetrics metrics(painter.font());
+ size = metrics.boundingRect(str);
+ painter.drawText(x - (size.right() - size.left()), zeroHeight + 9, str);
+
+ penPath.moveTo(x,y);
+ }
+
+ if(i == CursorAPos || i == CursorBPos) {
+ QPainterPath *cursorPath;
+
+ if(i == CursorAPos) {
+ cursorPath = &cursorAPath;
+ } else {
+ cursorPath = &cursorBPath;
+ }
+ cursorPath->moveTo(x, r.top());
+ cursorPath->lineTo(x, r.bottom());
+ penPath.moveTo(x, y);
+ }
+ }
+
+ if(n != 0) {
+ yMean /= n;
+ }
+
+ painter.setPen(QColor(255, 255, 255));
+ painter.drawPath(whitePath);
+ painter.setPen(pen);
+ painter.drawPath(penPath);
+ painter.setPen(QColor(255, 255, 0));
+ painter.drawPath(cursorAPath);
+ painter.setPen(QColor(255, 0, 255));
+ painter.drawPath(cursorBPath);
+
+ char str[100];
+ sprintf(str, "@%d max=%d min=%d mean=%d n=%d/%d dt=%d [%.3f] zoom=%.3f CursorA=%d [%d] CursorB=%d [%d]",
+ GraphStart, yMax, yMin, yMean, n, GraphTraceLen,
+ CursorBPos - CursorAPos, (CursorBPos - CursorAPos)/CursorScaleFactor,GraphPixelsPerPoint,CursorAPos,GraphBuffer[CursorAPos],CursorBPos,GraphBuffer[CursorBPos]);
+
+ painter.setPen(QColor(255, 255, 255));
+ painter.drawText(50, r.bottom() - 20, str);
+}
+
+ProxWidget::ProxWidget(QWidget *parent) : QWidget(parent), GraphStart(0), GraphPixelsPerPoint(1)
+{
+ resize(600, 500);
+
+ QPalette palette(QColor(0,0,0,0));
+ palette.setColor(QPalette::WindowText, QColor(255,255,255));
+ palette.setColor(QPalette::Text, QColor(255,255,255));
+ palette.setColor(QPalette::Button, QColor(100, 100, 100));
+ setPalette(palette);
+ setAutoFillBackground(true);
+}
+
+void ProxWidget::closeEvent(QCloseEvent *event)
+{
+ event->ignore();
+ this->hide();
+}
+
+void ProxWidget::mouseMoveEvent(QMouseEvent *event)
+{
+ int x = event->x();
+ x -= 40;
+ x = (int)(x / GraphPixelsPerPoint);
+ x += GraphStart;
+ if((event->buttons() & Qt::LeftButton)) {
+ CursorAPos = x;
+ } else if (event->buttons() & Qt::RightButton) {
+ CursorBPos = x;
+ }
+
+
+ this->update();
+}
+
+void ProxWidget::keyPressEvent(QKeyEvent *event)
+{
+ switch(event->key()) {
+ case Qt::Key_Down:
+ if(GraphPixelsPerPoint <= 50) {
+ GraphPixelsPerPoint *= 2;
+ }
+ break;
+
+ case Qt::Key_Up:
+ if(GraphPixelsPerPoint >= 0.02) {
+ GraphPixelsPerPoint /= 2;
+ }
+ break;
+
+ case Qt::Key_Right:
+ if(GraphPixelsPerPoint < 20) {
+ GraphStart += (int)(20 / GraphPixelsPerPoint);
+ } else {
+ GraphStart++;
+ }
+ break;
+
+ case Qt::Key_Left:
+ if(GraphPixelsPerPoint < 20) {
+ GraphStart -= (int)(20 / GraphPixelsPerPoint);
+ } else {
+ GraphStart--;
+ }
+ break;
+
+ default:
+ QWidget::keyPressEvent(event);
+ return;
+ break;
+ }
+
+ this->update();
+}
--- /dev/null
+#include <QApplication>
+#include <QPushButton>
+#include <QObject>
+#include <QWidget>
+#include <QPainter>
+
+class ProxWidget : public QWidget
+{
+ Q_OBJECT;
+
+ private:
+ int GraphStart;
+ double GraphPixelsPerPoint;
+ int CursorAPos;
+ int CursorBPos;
+
+ public:
+ ProxWidget(QWidget *parent = 0);
+
+ protected:
+ void paintEvent(QPaintEvent *event);
+ void closeEvent(QCloseEvent *event);
+ void mouseMoveEvent(QMouseEvent *event);
+ void mousePressEvent(QMouseEvent *event) { mouseMoveEvent(event); }
+ void keyPressEvent(QKeyEvent *event);
+};
+
+class ProxGuiQT : public QObject
+{
+ Q_OBJECT;
+
+ private:
+ QApplication *plotapp;
+ ProxWidget *plotwidget;
+ int argc;
+ char **argv;
+ void (*main_func)(void);
+
+ public:
+ ProxGuiQT(int argc, char **argv);
+ ~ProxGuiQT(void);
+ void ShowGraphWindow(void);
+ void RepaintGraphWindow(void);
+ void HideGraphWindow(void);
+ void MainLoop(void);
+
+ private slots:
+ void _ShowGraphWindow(void);
+ void _RepaintGraphWindow(void);
+ void _HideGraphWindow(void);
+
+ signals:
+ void ShowGraphWindowSignal(void);
+ void RepaintGraphWindowSignal(void);
+ void HideGraphWindowSignal(void);
+};
--- /dev/null
+#include <usb.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <string.h>
+#include <errno.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+#include <pthread.h>
+
+#include "translate.h"
+#include "prox.h"
+#include "proxmark3.h"
+#include "proxgui.h"
+
+struct usb_receiver_arg {
+ int run;
+};
+
+struct main_loop_arg {
+ int usb_present;
+};
+
+static void *usb_receiver(void *targ) {
+ struct usb_receiver_arg *arg = (struct usb_receiver_arg*)targ;
+ UsbCommand cmdbuf;
+
+ while(arg->run) {
+ if (ReceiveCommandP(&cmdbuf) > 0) {
+ int i;
+
+ for (i=0; i<strlen(PROXPROMPT); i++)
+ putchar(0x08);
+
+ UsbCommandReceived(&cmdbuf);
+ printf(PROXPROMPT);
+ fflush(NULL);
+ }
+ }
+
+ pthread_exit(NULL);
+}
+
+static void *main_loop(void *targ)
+{
+ struct main_loop_arg *arg = (struct main_loop_arg*)targ;
+ char *cmd = NULL;
+
+ while(1) {
+ struct usb_receiver_arg rarg;
+ pthread_t reader_thread;
+
+ rarg.run=1;
+ if (arg->usb_present == 1) {
+ pthread_create(&reader_thread, NULL, &usb_receiver, &rarg);
+ }
+ cmd = readline(PROXPROMPT);
+ rarg.run=0;
+ if (arg->usb_present == 1) {
+ pthread_join(reader_thread, NULL);
+ }
+
+ if (cmd) {
+ if (cmd[0] != 0x00) {
+ CommandReceived(cmd);
+ add_history(cmd);
+ }
+ free(cmd);
+ } else {
+ printf("\n");
+ break;
+ }
+ }
+
+ ExitGraphics();
+ pthread_exit(NULL);
+}
+
+int main(int argc, char **argv)
+{
+ struct main_loop_arg marg;
+ pthread_t main_loop_t;
+ usb_init();
+
+ if (!(devh = OpenProxmark(1))) {
+ fprintf(stderr,"PROXMARK3: NOT FOUND!\n");
+ marg.usb_present = 0;
+ offline = 1;
+ } else {
+ marg.usb_present = 1;
+ offline = 0;
+ }
+
+ pthread_create(&main_loop_t, NULL, &main_loop, &marg);
+ InitGraphics(argc, argv);
+
+ MainGraphics();
+
+ pthread_join(main_loop_t, NULL);
+
+ if (marg.usb_present == 1) {
+ CloseProxmark();
+ }
+ return 0;
+}
--- /dev/null
+#define PROXPROMPT "proxmark3> "
+
+#define FLASH_ADDR_OS 0x10000
+#define FLASH_ADDR_FPGA 0x2000
+
+extern usb_dev_handle *devh;
+extern unsigned char return_on_error;
+extern unsigned char error_occured;
+
+int ReceiveCommandP(UsbCommand *c);
+usb_dev_handle* OpenProxmark(int);
+void CloseProxmark(void);
+
+void setlogfilename(char *fn);
--- /dev/null
+#include <usb.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <string.h>
+#include <errno.h>
+
+#include "translate.h"
+#include "prox.h"
+#include "proxmark3.h"
+
+#define HANDLE_ERROR if (error_occured) { \
+ error_occured = 0;\
+ break;\
+}
+
+int main()
+{
+ usb_init();
+ setlogfilename("snooper.log");
+
+ return_on_error = 1;
+
+ while(1) {
+ while(!(devh=OpenProxmark(0))) { sleep(1); }
+
+ while(1) {
+ UsbCommand cmdbuf;
+ int i;
+
+ CommandReceived("hi14asnoop");
+ HANDLE_ERROR
+
+ ReceiveCommand(&cmdbuf);
+ HANDLE_ERROR
+ for (i=0; i<5; i++) {
+ ReceiveCommandP(&cmdbuf);
+ }
+ HANDLE_ERROR
+
+ CommandReceived("hi14alist");
+ HANDLE_ERROR
+ }
+ }
+
+ CloseProxmark();
+ return 0;
+}
--- /dev/null
+#define BYTE unsigned char
+#define WORD unsigned short
+#define DWORD unsigned int
+#define TRUE 1
+#define FALSE 0
+#define BOOL int
+
+#define max(a,b) (((a)>(b))?(a):(b))
+#define min(a,b) (((a)>(b))?(b):(a))
--- /dev/null
+#!/bin/sh
+
+for i in /sys/bus/usb/devices/*; do
+ if grep "9ac4" "${i}/idVendor" >/dev/null 2>&1; then
+ echo "Found Proxmark..."
+ dev=`basename "${i}"`
+
+ for j in /sys/bus/usb/drivers/usbhid/*; do
+ if basename "${j}"|grep "^${dev}" >/dev/null; then
+ bound="`basename "${j}"`"
+ echo "Unbinding ${bound}..."
+ echo -n "${bound}" >/sys/bus/usb/drivers/usbhid/unbind
+ fi
+ done
+ fi
+done
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <usb.h>
+#include <strings.h>
+#include <errno.h>
+
+#include "translate.h"
+#include "prox.h"
+#include "proxmark3.h"
+
+usb_dev_handle *devh = NULL;
+static unsigned int claimed_iface = 0;
+unsigned char return_on_error = 0;
+unsigned char error_occured = 0;
+
+void SendCommand(UsbCommand *c, BOOL wantAck) {
+ int ret;
+
+#if 0
+ printf("Sending %d bytes\n", sizeof(UsbCommand));
+#endif
+ ret = usb_bulk_write(devh, 0x01, (char*)c, sizeof(UsbCommand), 1000);
+ if (ret<0) {
+ error_occured = 1;
+ if (return_on_error)
+ return;
+
+ fprintf(stderr, "write failed: %s!\nTrying to reopen device...\n",
+ usb_strerror());
+
+ if (devh) {
+ usb_close(devh);
+ devh = NULL;
+ }
+ while(!(devh=OpenProxmark(0))) { sleep(1); }
+ printf(PROXPROMPT);
+ fflush(NULL);
+
+ return;
+ }
+
+ if(wantAck) {
+ UsbCommand ack;
+ ReceiveCommand(&ack);
+ if(ack.cmd != CMD_ACK) {
+ printf("bad ACK\n");
+ exit(-1);
+ }
+ }
+}
+
+int ReceiveCommandP(UsbCommand *c) {
+ int ret;
+
+ bzero(c, sizeof(UsbCommand));
+ ret = usb_bulk_read(devh, 0x82, (char*)c, sizeof(UsbCommand), 500);
+ if (ret<0) {
+ if (ret != -ETIMEDOUT) {
+ error_occured = 1;
+ if (return_on_error)
+ return 0;
+
+ fprintf(stderr, "read failed: %s(%d)!\nTrying to reopen device...\n",
+ usb_strerror(), ret);
+
+ if (devh) {
+ usb_close(devh);
+ devh = NULL;
+ }
+ while(!(devh=OpenProxmark(0))) { sleep(1); }
+ printf(PROXPROMPT);
+ fflush(NULL);
+
+ return 0;
+ }
+ } else {
+ if (ret && (ret < sizeof(UsbCommand))) {
+ fprintf(stderr, "Read only %d instead of requested %d bytes!\n",
+ ret, (int)sizeof(UsbCommand));
+ }
+
+#if 0
+ {
+ int i;
+
+ printf("Read %d bytes\n", ret);
+ for (i = 0; i < ret; i++) {
+ printf("0x%02X ", ((unsigned char*)c)[i]);
+ if (!((i+1)%8))
+ printf("\n");
+ }
+ printf("\n");
+ }
+#endif
+ }
+
+ return ret;
+}
+
+void ReceiveCommand(UsbCommand *c) {
+ while(ReceiveCommandP(c)<0) {}
+}
+
+usb_dev_handle* findProxmark(int verbose, unsigned int *iface) {
+ struct usb_bus *busses, *bus;
+ usb_dev_handle *handle = NULL;
+
+ usb_find_busses();
+ usb_find_devices();
+
+ busses = usb_get_busses();
+
+ for (bus = busses; bus; bus = bus->next) {
+ struct usb_device *dev;
+
+ for (dev = bus->devices; dev; dev = dev->next) {
+ struct usb_device_descriptor *desc = &(dev->descriptor);
+
+ if ((desc->idProduct == 0x4b8f) && (desc->idVendor == 0x9ac4)) {
+ handle = usb_open(dev);
+ if (!handle) {
+ if (verbose)
+ fprintf(stderr, "open failed: %s!\n", usb_strerror());
+ return NULL;
+ }
+
+ *iface = dev->config[0].interface[0].altsetting[0].bInterfaceNumber;
+
+ return handle;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+usb_dev_handle* OpenProxmark(int verbose) {
+ int ret;
+ usb_dev_handle *handle = NULL;
+ unsigned int iface;
+
+#ifndef __APPLE__
+ handle = findProxmark(verbose, &iface);
+ if (!handle)
+ return NULL;
+
+ /* Whatever... */
+ usb_reset(handle);
+#endif
+
+ handle = findProxmark(verbose, &iface);
+ if (!handle)
+ return NULL;
+
+#ifndef __APPLE__
+ /* detach kernel driver first */
+ ret = usb_detach_kernel_driver_np(handle, iface);
+ /* don't complain if no driver attached */
+ if (ret<0 && ret != -61 && verbose)
+ fprintf(stderr, "detach kernel driver failed: (%d) %s!\n", ret, usb_strerror());
+#endif
+ ret = usb_claim_interface(handle, iface);
+ if (ret<0) {
+ if (verbose)
+ fprintf(stderr, "claim failed: %s!\n", usb_strerror());
+ return NULL;
+ }
+
+ claimed_iface = iface;
+ devh = handle;
+ return handle;
+}
+
+void CloseProxmark(void) {
+ usb_release_interface(devh, claimed_iface);
+ usb_close(devh);
+}
+++ /dev/null
-#COMMON_FLAGS = -m32
-LDLIBS = -L/usr/local/lib -lusb -lreadline -lpthread
-LDFLAGS = $(COMMON_FLAGS)
-CFLAGS = -I. -I/opt/local/include -Wall -Wno-unused-function $(COMMON_FLAGS)
-
-CXXFLAGS = $(shell pkg-config --cflags QtCore QtGui 2>/dev/null) -Wall
-QTLDLIBS = $(shell pkg-config --libs QtCore QtGui 2>/dev/null)
-
-ifneq ($(QTLDLIBS),)
-QTGUI = proxgui.o proxguiqt.o proxguiqt.moc.o
-CFLAGS += -DHAVE_GUI
-MOC = $(shell type moc-qt4 >/dev/null 2>&1 && echo moc-qt4 || echo moc)
-LINK.o = $(LINK.cpp)
-else
-QTGUI = guidummy.o
-endif
-
-all: proxmark3 snooper cli flasher
-
-all-static: LDLIBS:=-static $(LDLIBS)
-all-static: snooper cli flasher
-
-proxmark3: LDLIBS+=$(QTLDLIBS)
-proxmark3: proxmark3.o gui.o command.o usb.o $(QTGUI)
-
-command.o: ../winsrc/command.cpp translate.h
-
-snooper: snooper.o gui.o command.o usb.o guidummy.o
-
-cli: cli.o gui.o command.o usb.o guidummy.o
-
-flasher: flasher.o usb.o
-
-proxguiqt.moc.cpp: proxguiqt.h
- $(MOC) -o$@ $^
-
-clean:
- rm -f cli flasher proxmark3 snooper *.o *.moc.cpp
-
-.PHONY: all clean
+++ /dev/null
-#include <usb.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <strings.h>
-#include <string.h>
-#include <errno.h>
-
-#include "translate.h"
-#include "../winsrc/prox.h"
-#include "proxmark3.h"
-
-#define HANDLE_ERROR if (error_occured) { \
- error_occured = 0;\
- break;\
-}
-
-int main(int argc, char **argv)
-{
- if(argc != 3 && argc != 4)
- {
- printf("\n\tusage: cli <command 1> <command 2> [logfile (default cli.log)]\n");
- printf("\n");
- printf("\texample: cli hi14asnoop hi14alist h14a.log\n");
- printf("\n");
- return -1;
- }
-
- usb_init();
- if (argc == 4)
- setlogfilename(argv[3]);
- else
- setlogfilename("cli.log");
-
- return_on_error = 1;
-
- while(1) {
- while(!(devh=OpenProxmark(0))) { sleep(1); }
-
- while(1) {
- UsbCommand cmdbuf;
- int i;
-
- CommandReceived(argv[1]);
- HANDLE_ERROR
-
- ReceiveCommand(&cmdbuf);
- HANDLE_ERROR
- for (i=0; i<5; i++) {
- ReceiveCommandP(&cmdbuf);
- }
- HANDLE_ERROR
-
- CommandReceived(argv[2]);
- HANDLE_ERROR
- }
- }
-
- CloseProxmark();
- return 0;
-}
+++ /dev/null
-#include "translate.h"
-#include "../winsrc/command.cpp"
+++ /dev/null
-#include <usb.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <strings.h>
-#include <string.h>
-#include <errno.h>
-#include <ctype.h>
-
-#include "translate.h"
-#include "../winsrc/prox.h"
-#include "proxmark3.h"
-
-static DWORD ExpectedAddr;
-static BYTE QueuedToSend[256];
-static BOOL AllWritten;
-#define PHYSICAL_FLASH_START 0x100000
-
-struct partition {
- int start;
- int end;
- int precious;
- const char *name;
-};
-struct partition partitions[] = {
- {0x100000, 0x102000, 1, "bootrom"},
- {0x102000, 0x110000, 0, "fpga"},
- {0x110000, 0x140000, 0, "os"},
-};
-
-/* If translate is set, subtract PHYSICAL_FLASH_START to translate for old
- * bootroms.
- */
-static void FlushPrevious(int translate)
-{
- UsbCommand c;
- memset(&c, 0, sizeof(c));
-
- printf("expected = %08x flush, ", ExpectedAddr);
-
- int i;
- for(i = 0; i < 240; i += 48) {
- c.cmd = CMD_SETUP_WRITE;
- memcpy(c.d.asBytes, QueuedToSend+i, 48);
- c.ext1 = (i/4);
- SendCommand(&c, TRUE);
- }
-
- c.cmd = CMD_FINISH_WRITE;
- c.ext1 = (ExpectedAddr-1) & (~255);
- if(translate) {
- c.ext1 -= PHYSICAL_FLASH_START;
- }
- printf("c.ext1 = %08x\r", c.ext1);
- memcpy(c.d.asBytes, QueuedToSend+240, 16);
- SendCommand(&c, TRUE);
-
- AllWritten = TRUE;
-}
-
-/* Where must be between start_addr (inclusive) and end_addr (exclusive).
- */
-static void GotByte(DWORD where, BYTE which, int start_addr, int end_addr, int translate)
-{
- AllWritten = FALSE;
-
- if(where < start_addr || where >= end_addr) {
- printf("bad: got byte at %08x, outside of range %08x-%08x\n", where, start_addr, end_addr);
- exit(-1);
- }
-
- if(where != ExpectedAddr) {
- printf("bad: got at %08x, expected at %08x\n", where, ExpectedAddr);
- exit(-1);
- }
- QueuedToSend[where & 255] = which;
- ExpectedAddr++;
-
- if((where & 255) == 255) {
- // we have completed a full page
- FlushPrevious(translate);
- }
-}
-
-static int HexVal(int c)
-{
- c = tolower(c);
- if(c >= '0' && c <= '9') {
- return c - '0';
- } else if(c >= 'a' && c <= 'f') {
- return (c - 'a') + 10;
- } else {
- printf("bad hex digit '%c'\n", c);
- exit(-1);
- }
-}
-
-static BYTE HexByte(char *s)
-{
- return (HexVal(s[0]) << 4) | HexVal(s[1]);
-}
-
-static void LoadFlashFromSRecords(const char *file, int start_addr, int end_addr, int translate)
-{
- ExpectedAddr = start_addr;
-
- FILE *f = fopen(file, "r");
- if(!f) {
- printf("couldn't open file\n");
- exit(-1);
- }
-
- char line[512];
- while(fgets(line, sizeof(line), f)) {
- if(memcmp(line, "S3", 2)==0) {
- char *s = line + 2;
- int len = HexByte(s) - 5;
- s += 2;
-
- char addrStr[9];
- memcpy(addrStr, s, 8);
- addrStr[8] = '\0';
- DWORD addr;
- sscanf(addrStr, "%x", &addr);
- s += 8;
-
- /* Accept files that are located at PHYSICAL_FLASH_START, and files that are located at 0 */
- if(addr < PHYSICAL_FLASH_START)
- addr += PHYSICAL_FLASH_START;
-
- int i;
- for(i = 0; i < len; i++) {
- while((addr+i) > ExpectedAddr) {
- GotByte(ExpectedAddr, 0xff, start_addr, end_addr, translate);
- }
- GotByte(addr+i, HexByte(s), start_addr, end_addr, translate);
- s += 2;
- }
- }
- }
-
- if(!AllWritten) FlushPrevious(translate);
-
- fclose(f);
- printf("\ndone.\n");
-}
-
-static int PrepareFlash(struct partition *p, const char *filename, unsigned int state)
-{
- int translate = 0;
- if(state & DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH) {
- UsbCommand c;
- c.cmd = CMD_START_FLASH;
- c.ext1 = p->start;
- c.ext2 = p->end;
-
- /* Only send magic when flashing bootrom */
- if(p->precious) {
- c.ext3 = START_FLASH_MAGIC;
- } else {
- c.ext3 = 0;
- }
- SendCommand(&c, TRUE);
- translate = 0;
- } else {
- fprintf(stderr, "Warning: Your bootloader does not understand the new START_FLASH command\n");
- fprintf(stderr, " It is recommended that you update your bootloader\n\n");
- translate = 1;
- }
-
- LoadFlashFromSRecords(filename, p->start, p->end, translate);
- return 1;
-}
-
-static unsigned int GetProxmarkState(void)
-{
- unsigned int state = 0;
-
- UsbCommand c;
- c.cmd = CMD_DEVICE_INFO;
- SendCommand(&c, FALSE);
-
- UsbCommand resp;
- ReceiveCommand(&resp);
- /* Three cases:
- * 1. The old bootrom code will ignore CMD_DEVICE_INFO, but respond with an ACK
- * 2. The old os code will respond with CMD_DEBUG_PRINT_STRING and "unknown command"
- * 3. The new bootrom and os codes will respond with CMD_DEVICE_INFO and flags
- */
-
- switch(resp.cmd) {
- case CMD_ACK:
- state = DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM;
- break;
- case CMD_DEBUG_PRINT_STRING:
- state = DEVICE_INFO_FLAG_CURRENT_MODE_OS;
- break;
- case CMD_DEVICE_INFO:
- state = resp.ext1;
- break;
- default:
- fprintf(stderr, "Couldn't get proxmark state, bad response type: 0x%04X\n", resp.cmd);
- exit(-1);
- break;
- }
-
-#if 0
- if(state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) printf("New bootrom present\n");
- if(state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) printf("New osimage present\n");
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) printf("Currently in bootrom\n");
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) printf("Currently in OS\n");
-#endif
-
- return state;
-}
-
-static unsigned int EnterFlashState(void)
-{
- unsigned int state = GetProxmarkState();
-
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) {
- /* Already in flash state, we're done. */
- return state;
- }
-
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) {
- fprintf(stderr,"Entering flash-mode...\n");
- UsbCommand c;
- bzero(&c, sizeof(c));
-
- if( (state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) && (state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) ) {
- /* New style handover: Send CMD_START_FLASH, which will reset the board and
- * enter the bootrom on the next boot.
- */
- c.cmd = CMD_START_FLASH;
- SendCommand(&c, FALSE);
- fprintf(stderr,"(You don't have to do anything. Press and release the button only if you want to abort)\n");
- fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");
- } else {
- /* Old style handover: Ask the user to press the button, then reset the board */
- c.cmd = CMD_HARDWARE_RESET;
- SendCommand(&c, FALSE);
- fprintf(stderr,"(Press and hold down button NOW if your bootloader requires it)\n");
- fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");
- }
-
- CloseProxmark();
- sleep(1);
-
- while(!(devh=OpenProxmark(0))) { sleep(1); }
- fprintf(stderr,"Found.\n");
-
- return GetProxmarkState();
- }
-
- return 0;
-}
-
-static void usage(char **argv)
-{
- int i;
- fprintf(stderr, "Usage: %s areas image [image [image]]\n", argv[0]);
- fprintf(stderr, " areas is a comma-separated list of areas to flash, with no spaces\n");
- fprintf(stderr, " Known areas are:");
- for(i=0; i<(sizeof(partitions)/sizeof(partitions[0])); i++) {
- fprintf(stderr, " %s", partitions[i].name);
- }
- fprintf(stderr, "\n");
- fprintf(stderr, " image is the path to the corresponding image\n\n");
- fprintf(stderr, "Example: %s os,fpga path/to/osimage.s19 path/to/fpgaimage.s19\n", argv[0]);
-}
-
-/* On first call, have *offset = -1, *length = 0; */
-static int find_next_area(const char *str, int *offset, int *length)
-{
- if(*str == '\0') return 0;
- if((*offset >= 0) && str[*offset + *length] == '\0') return 0;
- *offset += 1 + *length;
-
- char *next_comma = strchr(str + *offset, ',');
- if(next_comma == NULL) {
- *length = strlen(str) - *offset;
- } else {
- *length = next_comma-(str+*offset);
- }
- return 1;
-}
-
-int main(int argc, char **argv) {
- if(argc < 2) {
- usage(argv);
- exit(-1);
- }
-
- /* Count area arguments */
- int areas = 0, offset=-1, length=0;
- while(find_next_area(argv[1], &offset, &length)) areas++;
-
- if(areas != argc - 2) {
- usage(argv);
- exit(-1);
- }
-
- usb_init();
-
- fprintf(stderr,"Waiting for Proxmark to appear on USB... ");
- while(!(devh=OpenProxmark(0))) { sleep(1); }
- fprintf(stderr,"Found.\n");
-
- unsigned int state = EnterFlashState();
-
- if( !(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) ) {
- fprintf(stderr, "Proxmark would not enter flash state, abort\n");
- exit(-1);
- }
-
- offset=-1; length=0;
- int current_area = 0;
- while(find_next_area(argv[1], &offset, &length)) {
- int i;
- struct partition *p = NULL;
- for(i=0; i<sizeof(partitions)/sizeof(partitions[0]); i++) {
- if(strncmp(partitions[i].name, argv[1] + offset, length) == 0) {
- /* Check if the name matches the bootrom partition, and if so, require "bootrom" to
- * be written in full. The other names may be abbreviated.
- */
- if(!partitions[i].precious || (strlen(partitions[i].name) == length)) {
- p = &partitions[i];
- }
- break;
- }
- }
-
- if(p == NULL) {
- fprintf(stderr, "Warning: area name '");
- fwrite(argv[1]+offset, length, 1, stderr);
- fprintf(stderr, "' unknown, ignored\n");
- } else {
- fprintf(stderr, "Flashing %s from %s\n", p->name, argv[2+current_area]);
- PrepareFlash(p, argv[2+current_area], state);
- }
- current_area++;
- }
-
- UsbCommand c;
- bzero(&c, sizeof(c));
- c.cmd = CMD_HARDWARE_RESET;
- SendCommand(&c, FALSE);
-
- CloseProxmark();
-
- fprintf(stderr,"Have a nice day!\n");
-
- return 0;
-}
+++ /dev/null
-#include <stdarg.h>
-#include <stdio.h>
-#include <time.h>
-
-#include "proxgui.h"
-#include "translate.h"
-#include "../winsrc/prox.h"
-
-int GraphBuffer[MAX_GRAPH_TRACE_LEN];
-int GraphTraceLen;
-double CursorScaleFactor;
-int PlotGridX, PlotGridY;
-int CommandFinished;
-int offline;
-
-static char *logfilename = "proxmark3.log";
-
-void PrintToScrollback(char *fmt, ...) {
- va_list argptr, argptr2;
- static FILE *logfile = NULL;
- static int logging=1;
-
- if (logging && !logfile) {
- logfile=fopen(logfilename, "a");
- if (!logfile) {
- fprintf(stderr, "Can't open logfile, logging disabled!\n");
- logging=0;
- }
- }
-
- va_start(argptr, fmt);
- va_copy(argptr2, argptr);
- vprintf(fmt, argptr);
- va_end(argptr);
- printf("\n");
- if (logging && logfile) {
-#if 0
- char zeit[25];
- time_t jetzt_t;
- struct tm *jetzt;
-
- jetzt_t = time(NULL);
- jetzt = localtime(&jetzt_t);
- strftime(zeit, 25, "%b %e %T", jetzt);
-
- fprintf(logfile,"%s ", zeit);
-#endif
- vfprintf(logfile, fmt, argptr2);
- fprintf(logfile,"\n");
- fflush(logfile);
- }
- va_end(argptr2);
-}
-
-void setlogfilename(char *fn)
-{
- logfilename = fn;
-}
+++ /dev/null
-#include <stdio.h>
-
-void ShowGraphWindow(void)
-{
- static int warned = 0;
-
- if (!warned) {
- printf("No GUI in this build!\n");
- warned = 1;
- }
-}
-
-void HideGraphWindow(void) {}
-void RepaintGraphWindow(void) {}
-void MainGraphics() {}
-void InitGraphics(int argc, char **argv) {}
-void ExitGraphics(void) {}
+++ /dev/null
-#include "proxgui.h"
-#include "proxguiqt.h"
-
-static ProxGuiQT *gui = NULL;
-
-extern "C" void ShowGraphWindow(void)
-{
- if (!gui)
- return;
-
- gui->ShowGraphWindow();
-}
-
-extern "C" void HideGraphWindow(void)
-{
- if (!gui)
- return;
-
- gui->HideGraphWindow();
-}
-
-extern "C" void RepaintGraphWindow(void)
-{
- if (!gui)
- return;
-
- gui->RepaintGraphWindow();
-}
-
-extern "C" void MainGraphics(void)
-{
- if (!gui)
- return;
-
- gui->MainLoop();
-}
-
-extern "C" void InitGraphics(int argc, char **argv)
-{
-#ifdef Q_WS_X11
- bool useGUI = getenv("DISPLAY") != 0;
-#else
- bool useGUI = true;
-#endif
- if (!useGUI)
- return;
-
- gui = new ProxGuiQT(argc, argv);
-}
-
-extern "C" void ExitGraphics(void)
-{
- if (!gui)
- return;
-
- delete gui;
- gui = NULL;
-}
+++ /dev/null
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void ShowGraphWindow(void);
-void HideGraphWindow(void);
-void RepaintGraphWindow(void);
-void MainGraphics(void);
-void InitGraphics(int argc, char **argv);
-void ExitGraphics(void);
-
-#define MAX_GRAPH_TRACE_LEN (1024*128)
-extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];
-extern int GraphTraceLen;
-extern double CursorScaleFactor;
-extern int PlotGridX, PlotGridY;
-extern int CommandFinished;
-extern int offline;
-
-#ifdef __cplusplus
-}
-#endif
+++ /dev/null
-#include <iostream>
-#include <QPainterPath>
-#include <QBrush>
-#include <QPen>
-#include <QTimer>
-#include <QCloseEvent>
-#include <QMouseEvent>
-#include <QKeyEvent>
-#include <math.h>
-#include <limits.h>
-#include <stdio.h>
-#include "proxguiqt.h"
-#include "proxgui.h"
-
-void ProxGuiQT::ShowGraphWindow(void)
-{
- emit ShowGraphWindowSignal();
-}
-
-void ProxGuiQT::RepaintGraphWindow(void)
-{
- emit RepaintGraphWindowSignal();
-}
-
-void ProxGuiQT::HideGraphWindow(void)
-{
- emit HideGraphWindowSignal();
-}
-
-void ProxGuiQT::_ShowGraphWindow(void)
-{
- if(!plotapp)
- return;
-
- if (!plotwidget)
- plotwidget = new ProxWidget();
-
- plotwidget->show();
-}
-
-void ProxGuiQT::_RepaintGraphWindow(void)
-{
- if (!plotapp || !plotwidget)
- return;
-
- plotwidget->update();
-}
-
-void ProxGuiQT::_HideGraphWindow(void)
-{
- if (!plotapp || !plotwidget)
- return;
-
- plotwidget->hide();
-}
-
-void ProxGuiQT::MainLoop()
-{
- plotapp = new QApplication(argc, argv);
-
- connect(this, SIGNAL(ShowGraphWindowSignal()), this, SLOT(_ShowGraphWindow()));
- connect(this, SIGNAL(RepaintGraphWindowSignal()), this, SLOT(_RepaintGraphWindow()));
- connect(this, SIGNAL(HideGraphWindowSignal()), this, SLOT(_HideGraphWindow()));
-
- plotapp->exec();
-}
-
-ProxGuiQT::ProxGuiQT(int argc, char **argv) : plotapp(NULL), plotwidget(NULL),
- argc(argc), argv(argv)
-{
-}
-
-ProxGuiQT::~ProxGuiQT(void)
-{
- if (plotwidget) {
- delete plotwidget;
- plotwidget = NULL;
- }
-
- if (plotapp) {
- plotapp->quit();
- delete plotapp;
- plotapp = NULL;
- }
-}
-
-void ProxWidget::paintEvent(QPaintEvent *event)
-{
- QPainter painter(this);
- QPainterPath penPath, whitePath, greyPath, lightgreyPath, cursorAPath, cursorBPath;
- QRect r;
- QBrush brush(QColor(100, 255, 100));
- QPen pen(QColor(100, 255, 100));
-
- painter.setFont(QFont("Arial", 10));
-
- if(GraphStart < 0) {
- GraphStart = 0;
- }
-
- if (CursorAPos > GraphTraceLen)
- CursorAPos= 0;
- if(CursorBPos > GraphTraceLen)
- CursorBPos= 0;
-
- r = rect();
-
- painter.fillRect(r, QColor(0, 0, 0));
-
- whitePath.moveTo(r.left() + 40, r.top());
- whitePath.lineTo(r.left() + 40, r.bottom());
-
- int zeroHeight = r.top() + (r.bottom() - r.top()) / 2;
-
- greyPath.moveTo(r.left(), zeroHeight);
- greyPath.lineTo(r.right(), zeroHeight);
- painter.setPen(QColor(100, 100, 100));
- painter.drawPath(greyPath);
-
- // plot X and Y grid lines
- int i;
- if ((PlotGridX > 0) && ((PlotGridX * GraphPixelsPerPoint) > 1)) {
- for(i = 40; i < r.right(); i += (int)(PlotGridX * GraphPixelsPerPoint)) {
- //SelectObject(hdc, GreyPenLite);
- //MoveToEx(hdc, r.left + i, r.top, NULL);
- //LineTo(hdc, r.left + i, r.bottom);
- lightgreyPath.moveTo(r.left()+i,r.top());
- lightgreyPath.lineTo(r.left()+i,r.bottom());
- painter.drawPath(lightgreyPath);
- }
- }
- if ((PlotGridY > 0) && ((PlotGridY * GraphPixelsPerPoint) > 1)){
- for(i = 0; i < ((r.top() + r.bottom())>>1); i += (int)(PlotGridY * GraphPixelsPerPoint)) {
- lightgreyPath.moveTo(r.left() + 40,zeroHeight + i);
- lightgreyPath.lineTo(r.right(),zeroHeight + i);
- painter.drawPath(lightgreyPath);
- lightgreyPath.moveTo(r.left() + 40,zeroHeight - i);
- lightgreyPath.lineTo(r.right(),zeroHeight - i);
- painter.drawPath(lightgreyPath);
- }
- }
-
- int startMax =
- (GraphTraceLen - (int)((r.right() - r.left() - 40) / GraphPixelsPerPoint));
- if(startMax < 0) {
- startMax = 0;
- }
- if(GraphStart > startMax) {
- GraphStart = startMax;
- }
-
- int absYMax = 1;
-
- for(i = GraphStart; ; i++) {
- if(i >= GraphTraceLen) {
- break;
- }
- if(fabs((double)GraphBuffer[i]) > absYMax) {
- absYMax = (int)fabs((double)GraphBuffer[i]);
- }
- int x = 40 + (int)((i - GraphStart)*GraphPixelsPerPoint);
- if(x > r.right()) {
- break;
- }
- }
-
- absYMax = (int)(absYMax*1.2 + 1);
-
- // number of points that will be plotted
- int span = (int)((r.right() - r.left()) / GraphPixelsPerPoint);
- // one label every 100 pixels, let us say
- int labels = (r.right() - r.left() - 40) / 100;
- if(labels <= 0) labels = 1;
- int pointsPerLabel = span / labels;
- if(pointsPerLabel <= 0) pointsPerLabel = 1;
-
- int yMin = INT_MAX;
- int yMax = INT_MIN;
- int yMean = 0;
- int n = 0;
-
- for(i = GraphStart; ; i++) {
- if(i >= GraphTraceLen) {
- break;
- }
- int x = 40 + (int)((i - GraphStart)*GraphPixelsPerPoint);
- if(x > r.right() + GraphPixelsPerPoint) {
- break;
- }
-
- int y = GraphBuffer[i];
- if(y < yMin) {
- yMin = y;
- }
- if(y > yMax) {
- yMax = y;
- }
- yMean += y;
- n++;
-
- y = (y * (r.top() - r.bottom()) / (2*absYMax)) + zeroHeight;
- if(i == GraphStart) {
- penPath.moveTo(x, y);
- } else {
- penPath.lineTo(x, y);
- }
-
- if(GraphPixelsPerPoint > 10) {
- QRect f(QPoint(x - 3, y - 3),QPoint(x + 3, y + 3));
- painter.fillRect(f, brush);
- }
-
- if(((i - GraphStart) % pointsPerLabel == 0) && i != GraphStart) {
- whitePath.moveTo(x, zeroHeight - 3);
- whitePath.lineTo(x, zeroHeight + 3);
-
- char str[100];
- sprintf(str, "+%d", (i - GraphStart));
-
- painter.setPen(QColor(255, 255, 255));
- QRect size;
- QFontMetrics metrics(painter.font());
- size = metrics.boundingRect(str);
- painter.drawText(x - (size.right() - size.left()), zeroHeight + 9, str);
-
- penPath.moveTo(x,y);
- }
-
- if(i == CursorAPos || i == CursorBPos) {
- QPainterPath *cursorPath;
-
- if(i == CursorAPos) {
- cursorPath = &cursorAPath;
- } else {
- cursorPath = &cursorBPath;
- }
- cursorPath->moveTo(x, r.top());
- cursorPath->lineTo(x, r.bottom());
- penPath.moveTo(x, y);
- }
- }
-
- if(n != 0) {
- yMean /= n;
- }
-
- painter.setPen(QColor(255, 255, 255));
- painter.drawPath(whitePath);
- painter.setPen(pen);
- painter.drawPath(penPath);
- painter.setPen(QColor(255, 255, 0));
- painter.drawPath(cursorAPath);
- painter.setPen(QColor(255, 0, 255));
- painter.drawPath(cursorBPath);
-
- char str[100];
- sprintf(str, "@%d max=%d min=%d mean=%d n=%d/%d dt=%d [%.3f] zoom=%.3f CursorA=%d [%d] CursorB=%d [%d]",
- GraphStart, yMax, yMin, yMean, n, GraphTraceLen,
- CursorBPos - CursorAPos, (CursorBPos - CursorAPos)/CursorScaleFactor,GraphPixelsPerPoint,CursorAPos,GraphBuffer[CursorAPos],CursorBPos,GraphBuffer[CursorBPos]);
-
- painter.setPen(QColor(255, 255, 255));
- painter.drawText(50, r.bottom() - 20, str);
-}
-
-ProxWidget::ProxWidget(QWidget *parent) : QWidget(parent), GraphStart(0), GraphPixelsPerPoint(1)
-{
- resize(600, 500);
-
- QPalette palette(QColor(0,0,0,0));
- palette.setColor(QPalette::WindowText, QColor(255,255,255));
- palette.setColor(QPalette::Text, QColor(255,255,255));
- palette.setColor(QPalette::Button, QColor(100, 100, 100));
- setPalette(palette);
- setAutoFillBackground(true);
-}
-
-void ProxWidget::closeEvent(QCloseEvent *event)
-{
- event->ignore();
- this->hide();
-}
-
-void ProxWidget::mouseMoveEvent(QMouseEvent *event)
-{
- int x = event->x();
- x -= 40;
- x = (int)(x / GraphPixelsPerPoint);
- x += GraphStart;
- if((event->buttons() & Qt::LeftButton)) {
- CursorAPos = x;
- } else if (event->buttons() & Qt::RightButton) {
- CursorBPos = x;
- }
-
-
- this->update();
-}
-
-void ProxWidget::keyPressEvent(QKeyEvent *event)
-{
- switch(event->key()) {
- case Qt::Key_Down:
- if(GraphPixelsPerPoint <= 50) {
- GraphPixelsPerPoint *= 2;
- }
- break;
-
- case Qt::Key_Up:
- if(GraphPixelsPerPoint >= 0.02) {
- GraphPixelsPerPoint /= 2;
- }
- break;
-
- case Qt::Key_Right:
- if(GraphPixelsPerPoint < 20) {
- GraphStart += (int)(20 / GraphPixelsPerPoint);
- } else {
- GraphStart++;
- }
- break;
-
- case Qt::Key_Left:
- if(GraphPixelsPerPoint < 20) {
- GraphStart -= (int)(20 / GraphPixelsPerPoint);
- } else {
- GraphStart--;
- }
- break;
-
- default:
- QWidget::keyPressEvent(event);
- return;
- break;
- }
-
- this->update();
-}
+++ /dev/null
-#include <QApplication>
-#include <QPushButton>
-#include <QObject>
-#include <QWidget>
-#include <QPainter>
-
-class ProxWidget : public QWidget
-{
- Q_OBJECT;
-
- private:
- int GraphStart;
- double GraphPixelsPerPoint;
- int CursorAPos;
- int CursorBPos;
-
- public:
- ProxWidget(QWidget *parent = 0);
-
- protected:
- void paintEvent(QPaintEvent *event);
- void closeEvent(QCloseEvent *event);
- void mouseMoveEvent(QMouseEvent *event);
- void mousePressEvent(QMouseEvent *event) { mouseMoveEvent(event); }
- void keyPressEvent(QKeyEvent *event);
-};
-
-class ProxGuiQT : public QObject
-{
- Q_OBJECT;
-
- private:
- QApplication *plotapp;
- ProxWidget *plotwidget;
- int argc;
- char **argv;
- void (*main_func)(void);
-
- public:
- ProxGuiQT(int argc, char **argv);
- ~ProxGuiQT(void);
- void ShowGraphWindow(void);
- void RepaintGraphWindow(void);
- void HideGraphWindow(void);
- void MainLoop(void);
-
- private slots:
- void _ShowGraphWindow(void);
- void _RepaintGraphWindow(void);
- void _HideGraphWindow(void);
-
- signals:
- void ShowGraphWindowSignal(void);
- void RepaintGraphWindowSignal(void);
- void HideGraphWindowSignal(void);
-};
+++ /dev/null
-#include <usb.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <strings.h>
-#include <string.h>
-#include <errno.h>
-#include <readline/readline.h>
-#include <readline/history.h>
-#include <pthread.h>
-
-#include "translate.h"
-#include "../winsrc/prox.h"
-#include "proxmark3.h"
-#include "proxgui.h"
-
-struct usb_receiver_arg {
- int run;
-};
-
-struct main_loop_arg {
- int usb_present;
-};
-
-static void *usb_receiver(void *targ) {
- struct usb_receiver_arg *arg = (struct usb_receiver_arg*)targ;
- UsbCommand cmdbuf;
-
- while(arg->run) {
- if (ReceiveCommandP(&cmdbuf) > 0) {
- int i;
-
- for (i=0; i<strlen(PROXPROMPT); i++)
- putchar(0x08);
-
- UsbCommandReceived(&cmdbuf);
- printf(PROXPROMPT);
- fflush(NULL);
- }
- }
-
- pthread_exit(NULL);
-}
-
-static void *main_loop(void *targ)
-{
- struct main_loop_arg *arg = (struct main_loop_arg*)targ;
- char *cmd = NULL;
-
- while(1) {
- struct usb_receiver_arg rarg;
- pthread_t reader_thread;
-
- rarg.run=1;
- if (arg->usb_present == 1) {
- pthread_create(&reader_thread, NULL, &usb_receiver, &rarg);
- }
- cmd = readline(PROXPROMPT);
- rarg.run=0;
- if (arg->usb_present == 1) {
- pthread_join(reader_thread, NULL);
- }
-
- if (cmd) {
- if (cmd[0] != 0x00) {
- CommandReceived(cmd);
- add_history(cmd);
- }
- free(cmd);
- } else {
- printf("\n");
- break;
- }
- }
-
- ExitGraphics();
- pthread_exit(NULL);
-}
-
-int main(int argc, char **argv)
-{
- struct main_loop_arg marg;
- pthread_t main_loop_t;
- usb_init();
-
- if (!(devh = OpenProxmark(1))) {
- fprintf(stderr,"PROXMARK3: NOT FOUND!\n");
- marg.usb_present = 0;
- offline = 1;
- } else {
- marg.usb_present = 1;
- offline = 0;
- }
-
- pthread_create(&main_loop_t, NULL, &main_loop, &marg);
- InitGraphics(argc, argv);
-
- MainGraphics();
-
- pthread_join(main_loop_t, NULL);
-
- if (marg.usb_present == 1) {
- CloseProxmark();
- }
- return 0;
-}
+++ /dev/null
-#define PROXPROMPT "proxmark3> "
-
-#define FLASH_ADDR_OS 0x10000
-#define FLASH_ADDR_FPGA 0x2000
-
-extern usb_dev_handle *devh;
-extern unsigned char return_on_error;
-extern unsigned char error_occured;
-
-int ReceiveCommandP(UsbCommand *c);
-usb_dev_handle* OpenProxmark(int);
-void CloseProxmark(void);
-
-void setlogfilename(char *fn);
+++ /dev/null
-#include <usb.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <strings.h>
-#include <string.h>
-#include <errno.h>
-
-#include "translate.h"
-#include "../winsrc/prox.h"
-#include "proxmark3.h"
-
-#define HANDLE_ERROR if (error_occured) { \
- error_occured = 0;\
- break;\
-}
-
-int main()
-{
- usb_init();
- setlogfilename("snooper.log");
-
- return_on_error = 1;
-
- while(1) {
- while(!(devh=OpenProxmark(0))) { sleep(1); }
-
- while(1) {
- UsbCommand cmdbuf;
- int i;
-
- CommandReceived("hi14asnoop");
- HANDLE_ERROR
-
- ReceiveCommand(&cmdbuf);
- HANDLE_ERROR
- for (i=0; i<5; i++) {
- ReceiveCommandP(&cmdbuf);
- }
- HANDLE_ERROR
-
- CommandReceived("hi14alist");
- HANDLE_ERROR
- }
- }
-
- CloseProxmark();
- return 0;
-}
+++ /dev/null
-#define BYTE unsigned char
-#define WORD unsigned short
-#define DWORD unsigned int
-#define TRUE 1
-#define FALSE 0
-#define BOOL int
-
-#define max(a,b) (((a)>(b))?(a):(b))
-#define min(a,b) (((a)>(b))?(b):(a))
+++ /dev/null
-#!/bin/sh
-
-for i in /sys/bus/usb/devices/*; do
- if grep "9ac4" "${i}/idVendor" >/dev/null 2>&1; then
- echo "Found Proxmark..."
- dev=`basename "${i}"`
-
- for j in /sys/bus/usb/drivers/usbhid/*; do
- if basename "${j}"|grep "^${dev}" >/dev/null; then
- bound="`basename "${j}"`"
- echo "Unbinding ${bound}..."
- echo -n "${bound}" >/sys/bus/usb/drivers/usbhid/unbind
- fi
- done
- fi
-done
+++ /dev/null
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <usb.h>
-#include <strings.h>
-#include <errno.h>
-
-#include "translate.h"
-#include "../winsrc/prox.h"
-#include "proxmark3.h"
-
-usb_dev_handle *devh = NULL;
-static unsigned int claimed_iface = 0;
-unsigned char return_on_error = 0;
-unsigned char error_occured = 0;
-
-void SendCommand(UsbCommand *c, BOOL wantAck) {
- int ret;
-
-#if 0
- printf("Sending %d bytes\n", sizeof(UsbCommand));
-#endif
- ret = usb_bulk_write(devh, 0x01, (char*)c, sizeof(UsbCommand), 1000);
- if (ret<0) {
- error_occured = 1;
- if (return_on_error)
- return;
-
- fprintf(stderr, "write failed: %s!\nTrying to reopen device...\n",
- usb_strerror());
-
- if (devh) {
- usb_close(devh);
- devh = NULL;
- }
- while(!(devh=OpenProxmark(0))) { sleep(1); }
- printf(PROXPROMPT);
- fflush(NULL);
-
- return;
- }
-
- if(wantAck) {
- UsbCommand ack;
- ReceiveCommand(&ack);
- if(ack.cmd != CMD_ACK) {
- printf("bad ACK\n");
- exit(-1);
- }
- }
-}
-
-int ReceiveCommandP(UsbCommand *c) {
- int ret;
-
- bzero(c, sizeof(UsbCommand));
- ret = usb_bulk_read(devh, 0x82, (char*)c, sizeof(UsbCommand), 500);
- if (ret<0) {
- if (ret != -ETIMEDOUT) {
- error_occured = 1;
- if (return_on_error)
- return 0;
-
- fprintf(stderr, "read failed: %s(%d)!\nTrying to reopen device...\n",
- usb_strerror(), ret);
-
- if (devh) {
- usb_close(devh);
- devh = NULL;
- }
- while(!(devh=OpenProxmark(0))) { sleep(1); }
- printf(PROXPROMPT);
- fflush(NULL);
-
- return 0;
- }
- } else {
- if (ret && (ret < sizeof(UsbCommand))) {
- fprintf(stderr, "Read only %d instead of requested %d bytes!\n",
- ret, (int)sizeof(UsbCommand));
- }
-
-#if 0
- {
- int i;
-
- printf("Read %d bytes\n", ret);
- for (i = 0; i < ret; i++) {
- printf("0x%02X ", ((unsigned char*)c)[i]);
- if (!((i+1)%8))
- printf("\n");
- }
- printf("\n");
- }
-#endif
- }
-
- return ret;
-}
-
-void ReceiveCommand(UsbCommand *c) {
- while(ReceiveCommandP(c)<0) {}
-}
-
-usb_dev_handle* findProxmark(int verbose, unsigned int *iface) {
- struct usb_bus *busses, *bus;
- usb_dev_handle *handle = NULL;
-
- usb_find_busses();
- usb_find_devices();
-
- busses = usb_get_busses();
-
- for (bus = busses; bus; bus = bus->next) {
- struct usb_device *dev;
-
- for (dev = bus->devices; dev; dev = dev->next) {
- struct usb_device_descriptor *desc = &(dev->descriptor);
-
- if ((desc->idProduct == 0x4b8f) && (desc->idVendor == 0x9ac4)) {
- handle = usb_open(dev);
- if (!handle) {
- if (verbose)
- fprintf(stderr, "open failed: %s!\n", usb_strerror());
- return NULL;
- }
-
- *iface = dev->config[0].interface[0].altsetting[0].bInterfaceNumber;
-
- return handle;
- }
- }
- }
-
- return NULL;
-}
-
-usb_dev_handle* OpenProxmark(int verbose) {
- int ret;
- usb_dev_handle *handle = NULL;
- unsigned int iface;
-
-#ifndef __APPLE__
- handle = findProxmark(verbose, &iface);
- if (!handle)
- return NULL;
-
- /* Whatever... */
- usb_reset(handle);
-#endif
-
- handle = findProxmark(verbose, &iface);
- if (!handle)
- return NULL;
-
-#ifndef __APPLE__
- /* detach kernel driver first */
- ret = usb_detach_kernel_driver_np(handle, iface);
- /* don't complain if no driver attached */
- if (ret<0 && ret != -61 && verbose)
- fprintf(stderr, "detach kernel driver failed: (%d) %s!\n", ret, usb_strerror());
-#endif
- ret = usb_claim_interface(handle, iface);
- if (ret<0) {
- if (verbose)
- fprintf(stderr, "claim failed: %s!\n", usb_strerror());
- return NULL;
- }
-
- claimed_iface = iface;
- devh = handle;
- return handle;
-}
-
-void CloseProxmark(void) {
- usb_release_interface(devh, claimed_iface);
- usb_close(devh);
-}
+++ /dev/null
-CC=cl\r
-BASE_DIR ?= "..\..\devkitWIN"\r
-BASE_DEFS = /D_WIN32_WINNT=0x501 /DISOLATION_AWARE_ENABLED /D_WIN32_IE=0x600 /DWIN32_LEAN_AND_MEAN /DWIN32 /D_MT /D_CRT_SECURE_NO_WARNINGS\r
-BASE_CFLAGS = /W3 /nologo /Zi /MT /Fdobj/vc90.pdb\r
-LIB = $(BASE_DIR)\lib\r
-\r
-DEFINES = $(BASE_DEFS)\r
-INCLUDES = /I$(BASE_DIR)\include\r
-CFLAGS = $(BASE_CFLAGS) $(INCLUDES)\r
-\r
-OBJDIR = obj\r
-\r
-OBJS = $(OBJDIR)\prox.obj \\r
- $(OBJDIR)\gui.obj \\r
- $(OBJDIR)\command.obj\r
-\r
-LIBS = $(LIB)\user32.lib $(LIB)\gdi32.lib $(LIB)\setupapi.lib $(LIB)\libcmt.lib $(LIB)\oldnames.lib $(LIB)\kernel32.lib\r
-\r
-all: proxmark3\r
-\r
-proxmark3:\r
- $(CC) $(CFLAGS) $(DEFINES) -c -Foobj/prox.obj prox.cpp\r
- $(CC) $(CFLAGS) $(DEFINES) -c -Foobj/gui.obj gui.cpp\r
- $(CC) $(CFLAGS) $(DEFINES) -c -Foobj/command.obj command.cpp\r
- $(CC) $(CFLAGS) $(DEFINES) -Fe$(OBJDIR)/prox.exe $(OBJS) $(LIBS)\r
- copy obj\prox.exe .\r
-\r
-clean:\r
- del /q obj\*.obj\r
- del /q obj\*.ilk\r
- del /q obj\*.exe\r
- del /q obj\*.pdb\r
- del prox.exe
\ No newline at end of file
+++ /dev/null
-//-----------------------------------------------------------------------------\r
-// The actual command interpeter for what the user types at the command line.\r
-// Jonathan Westhues, Sept 2005\r
-// Edits by Gerhard de Koning Gans, Sep 2007 (##)\r
-//-----------------------------------------------------------------------------\r
-#include <windows.h>\r
-#include <stdlib.h>\r
-#include <string.h>\r
-#include <stdio.h>\r
-#include <limits.h>\r
-#include <math.h>\r
-\r
-#include "prox.h"\r
-#include "../common/iso14443_crc.c"\r
-#include "../common/crc16.c"\r
-\r
-#define arraylen(x) (sizeof(x)/sizeof((x)[0]))\r
-#define BIT(x) GraphBuffer[x * clock]\r
-#define BITS (GraphTraceLen / clock)\r
-\r
-int go = 0;\r
-static int CmdHisamplest(char *str, int nrlow);\r
-\r
-static void GetFromBigBuf(BYTE *dest, int bytes)\r
-{\r
- int n = bytes/4;\r
-\r
- if(n % 48 != 0) {\r
- PrintToScrollback("bad len in GetFromBigBuf");\r
- return;\r
- }\r
-\r
- int i;\r
- for(i = 0; i < n; i += 12) {\r
- UsbCommand c;\r
- c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- ReceiveCommand(&c);\r
- if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
- PrintToScrollback("bad resp");\r
- return;\r
- }\r
-\r
- memcpy(dest+(i*4), c.d.asBytes, 48);\r
- }\r
-}\r
-\r
-static void CmdReset(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_HARDWARE_RESET;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdBuffClear(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_BUFF_CLEAR;\r
- SendCommand(&c, FALSE);\r
- CmdClearGraph(TRUE);\r
-}\r
-\r
-static void CmdQuit(char *str)\r
-{\r
- exit(0);\r
-}\r
-\r
-static void CmdHIDdemodFSK(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_HID_DEMOD_FSK;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdTune(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_MEASURE_ANTENNA_TUNING;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi15read(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi14read(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-\r
-/* New command to read the contents of a SRI512 tag\r
- * SRI512 tags are ISO14443-B modulated memory tags,\r
- * this command just dumps the contents of the memory/\r
- */\r
-static void CmdSri512read(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_READ_SRI512_TAG;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-
-/* New command to read the contents of a SRIX4K tag
- * SRIX4K tags are ISO14443-B modulated memory tags,
- * this command just dumps the contents of the memory/
- */
-static void CmdSrix4kread(char *str)
-{
- UsbCommand c;
- c.cmd = CMD_READ_SRIX4K_TAG;
- c.ext1 = atoi(str);
- SendCommand(&c, FALSE);
-}
-
-
-\r
-// ## New command\r
-static void CmdHi14areader(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_READER_ISO_14443a;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-// ## New command\r
-static void CmdHi15reader(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_READER_ISO_15693;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-// ## New command\r
-static void CmdHi15tag(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SIMTAG_ISO_15693;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi14read_sim(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443_SIM;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi14readt(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-\r
- //CmdHisamplest(str);\r
- while(CmdHisamplest(str,atoi(str))==0) {\r
- c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
- }\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdHisimlisten(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SIMULATE_TAG_HF_LISTEN;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi14sim(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SIMULATE_TAG_ISO_14443;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi14asim(char *str) // ## simulate iso14443a tag\r
-{ // ## greg - added ability to specify tag UID\r
-\r
- unsigned int hi=0, lo=0;\r
- int n=0, i=0;\r
- UsbCommand c;\r
-\r
- while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
- hi=(hi<<4)|(lo>>28);\r
- lo=(lo<<4)|(n&0xf);\r
- }\r
-\r
- c.cmd = CMD_SIMULATE_TAG_ISO_14443a;\r
- // c.ext should be set to *str or convert *str to the correct format for a uid\r
- c.ext1 = hi;\r
- c.ext2 = lo;\r
- PrintToScrollback("Emulating 14443A TAG with UID %x%16x", hi, lo);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi14snoop(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SNOOP_ISO_14443;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdHi14asnoop(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SNOOP_ISO_14443a;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdLegicRfSim(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SIMULATE_TAG_LEGIC_RF;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdLegicRfRead(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_READER_LEGIC_RF;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdFPGAOff(char *str) // ## FPGA Control\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_FPGA_MAJOR_MODE_OFF;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-/* clear out our graph window */\r
-int CmdClearGraph(int redraw)\r
-{\r
- int gtl = GraphTraceLen;\r
- GraphTraceLen = 0;\r
-\r
- if (redraw)\r
- RepaintGraphWindow();\r
-\r
- return gtl;\r
-}\r
-\r
-/* write a bit to the graph */\r
-static void CmdAppendGraph(int redraw, int clock, int bit)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < (int)(clock/2); i++)\r
- GraphBuffer[GraphTraceLen++] = bit ^ 1;\r
-\r
- for (i = (int)(clock/2); i < clock; i++)\r
- GraphBuffer[GraphTraceLen++] = bit;\r
-\r
- if (redraw)\r
- RepaintGraphWindow();\r
-}\r
-\r
-/* Function is equivalent of loread + losamples + em410xread\r
- * looped until an EM410x tag is detected */\r
-static void CmdEM410xwatch(char *str)\r
-{\r
- char *zero = "";\r
- char *twok = "2000";\r
- go = 1;\r
-\r
- do\r
- {\r
- CmdLoread(zero);\r
- CmdLosamples(twok);\r
- CmdEM410xread(zero);\r
- } while (go);\r
-}\r
-\r
-/* Read the transmitted data of an EM4x50 tag\r
- * Format:\r
- *\r
- * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
- * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
- * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
- * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
- * CCCCCCCC <- column parity bits\r
- * 0 <- stop bit\r
- * LW <- Listen Window\r
- *\r
- * This pattern repeats for every block of data being transmitted.\r
- * Transmission starts with two Listen Windows (LW - a modulated\r
- * pattern of 320 cycles each (32/32/128/64/64)).\r
- *\r
- * Note that this data may or may not be the UID. It is whatever data\r
- * is stored in the blocks defined in the control word First and Last\r
- * Word Read values. UID is stored in block 32.\r
- */\r
-static void CmdEM4x50read(char *str)\r
-{\r
- int i, j, startblock, clock, skip, block, start, end, low, high;\r
- BOOL complete= FALSE;\r
- int tmpbuff[MAX_GRAPH_TRACE_LEN / 64];\r
- char tmp[6];\r
-\r
- high= low= 0;\r
- clock= 64;\r
-\r
- /* first get high and low values */\r
- for (i = 0; i < GraphTraceLen; i++)\r
- {\r
- if (GraphBuffer[i] > high)\r
- high = GraphBuffer[i];\r
- else if (GraphBuffer[i] < low)\r
- low = GraphBuffer[i];\r
- }\r
-\r
- /* populate a buffer with pulse lengths */\r
- i= 0;\r
- j= 0;\r
- while(i < GraphTraceLen)\r
- {\r
- // measure from low to low\r
- while((GraphBuffer[i] > low) && (i<GraphTraceLen))\r
- ++i;\r
- start= i;\r
- while((GraphBuffer[i] < high) && (i<GraphTraceLen))\r
- ++i;\r
- while((GraphBuffer[i] > low) && (i<GraphTraceLen))\r
- ++i;\r
- if (j>(MAX_GRAPH_TRACE_LEN/64)) {\r
- break;\r
- }\r
- tmpbuff[j++]= i - start;\r
- }\r
-\r
- /* look for data start - should be 2 pairs of LW (pulses of 192,128) */\r
- start= -1;\r
- skip= 0;\r
- for (i= 0; i < j - 4 ; ++i)\r
- {\r
- skip += tmpbuff[i];\r
- if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
- if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
- if (tmpbuff[i+2] >= 190 && tmpbuff[i+2] <= 194)\r
- if (tmpbuff[i+3] >= 126 && tmpbuff[i+3] <= 130)\r
- {\r
- start= i + 3;\r
- break;\r
- }\r
- }\r
- startblock= i + 3;\r
-\r
- /* skip over the remainder of the LW */\r
- skip += tmpbuff[i+1]+tmpbuff[i+2];\r
- while(skip < MAX_GRAPH_TRACE_LEN && GraphBuffer[skip] > low)\r
- ++skip;\r
- skip += 8;\r
-\r
- /* now do it again to find the end */\r
- end= start;\r
- for (i += 3; i < j - 4 ; ++i)\r
- {\r
- end += tmpbuff[i];\r
- if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
- if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
- if (tmpbuff[i+2] >= 190 && tmpbuff[i+2] <= 194)\r
- if (tmpbuff[i+3] >= 126 && tmpbuff[i+3] <= 130)\r
- {\r
- complete= TRUE;\r
- break;\r
- }\r
- }\r
-\r
- if (start >= 0)\r
- PrintToScrollback("Found data at sample: %i",skip);\r
- else\r
- {\r
- PrintToScrollback("No data found!");\r
- PrintToScrollback("Try again with more samples.");\r
- return;\r
- }\r
-\r
- if (!complete)\r
- {\r
- PrintToScrollback("*** Warning!");\r
- PrintToScrollback("Partial data - no end found!");\r
- PrintToScrollback("Try again with more samples.");\r
- }\r
-\r
- /* get rid of leading crap */\r
- sprintf(tmp,"%i",skip);\r
- CmdLtrim(tmp);\r
-\r
- /* now work through remaining buffer printing out data blocks */\r
- block= 0;\r
- i= startblock;\r
- while(block < 6)\r
- {\r
- PrintToScrollback("Block %i:", block);\r
- // mandemod routine needs to be split so we can call it for data\r
- // just print for now for debugging\r
- Cmdmanchesterdemod("i 64");\r
- skip= 0;\r
- /* look for LW before start of next block */\r
- for ( ; i < j - 4 ; ++i)\r
- {\r
- skip += tmpbuff[i];\r
- if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
- if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
- break;\r
- }\r
- while(GraphBuffer[skip] > low)\r
- ++skip;\r
- skip += 8;\r
- sprintf(tmp,"%i",skip);\r
- CmdLtrim(tmp);\r
- start += skip;\r
- block++;\r
- }\r
-}\r
-\r
-\r
-/* Read the ID of an EM410x tag.\r
- * Format:\r
- * 1111 1111 1 <-- standard non-repeatable header\r
- * XXXX [row parity bit] <-- 10 rows of 5 bits for our 40 bit tag ID\r
- * ....\r
- * CCCC <-- each bit here is parity for the 10 bits above in corresponding column\r
- * 0 <-- stop bit, end of tag\r
- */\r
-static void CmdEM410xread(char *str)\r
-{\r
- int i, j, clock, header, rows, bit, hithigh, hitlow, first, bit2idx, high, low;\r
- int parity[4];\r
- char id[11];\r
- int retested = 0;\r
- int BitStream[MAX_GRAPH_TRACE_LEN];\r
- high = low = 0;\r
-\r
- /* Detect high and lows and clock */\r
- for (i = 0; i < GraphTraceLen; i++)\r
- {\r
- if (GraphBuffer[i] > high)\r
- high = GraphBuffer[i];\r
- else if (GraphBuffer[i] < low)\r
- low = GraphBuffer[i];\r
- }\r
-\r
- /* get clock */\r
- clock = GetClock(str, high);\r
-\r
- /* parity for our 4 columns */\r
- parity[0] = parity[1] = parity[2] = parity[3] = 0;\r
- header = rows = 0;\r
-\r
- /* manchester demodulate */\r
- bit = bit2idx = 0;\r
- for (i = 0; i < (int)(GraphTraceLen / clock); i++)\r
- {\r
- hithigh = 0;\r
- hitlow = 0;\r
- first = 1;\r
-\r
- /* Find out if we hit both high and low peaks */\r
- for (j = 0; j < clock; j++)\r
- {\r
- if (GraphBuffer[(i * clock) + j] == high)\r
- hithigh = 1;\r
- else if (GraphBuffer[(i * clock) + j] == low)\r
- hitlow = 1;\r
-\r
- /* it doesn't count if it's the first part of our read\r
- because it's really just trailing from the last sequence */\r
- if (first && (hithigh || hitlow))\r
- hithigh = hitlow = 0;\r
- else\r
- first = 0;\r
-\r
- if (hithigh && hitlow)\r
- break;\r
- }\r
-\r
- /* If we didn't hit both high and low peaks, we had a bit transition */\r
- if (!hithigh || !hitlow)\r
- bit ^= 1;\r
-\r
- BitStream[bit2idx++] = bit;\r
- }\r
-\r
-retest:\r
- /* We go till 5 before the graph ends because we'll get that far below */\r
- for (i = 1; i < bit2idx - 5; i++)\r
- {\r
- /* Step 2: We have our header but need our tag ID */\r
- if (header == 9 && rows < 10)\r
- {\r
- /* Confirm parity is correct */\r
- if ((BitStream[i] ^ BitStream[i+1] ^ BitStream[i+2] ^ BitStream[i+3]) == BitStream[i+4])\r
- {\r
- /* Read another byte! */\r
- sprintf(id+rows, "%x", (8 * BitStream[i]) + (4 * BitStream[i+1]) + (2 * BitStream[i+2]) + (1 * BitStream[i+3]));\r
- rows++;\r
-\r
- /* Keep parity info */\r
- parity[0] ^= BitStream[i];\r
- parity[1] ^= BitStream[i+1];\r
- parity[2] ^= BitStream[i+2];\r
- parity[3] ^= BitStream[i+3];\r
-\r
- /* Move 4 bits ahead */\r
- i += 4;\r
- }\r
-\r
- /* Damn, something wrong! reset */\r
- else\r
- {\r
- PrintToScrollback("Thought we had a valid tag but failed at word %d (i=%d)", rows + 1, i);\r
-\r
- /* Start back rows * 5 + 9 header bits, -1 to not start at same place */\r
- i -= 9 + (5 * rows) - 5;\r
-\r
- rows = header = 0;\r
- }\r
- }\r
-\r
- /* Step 3: Got our 40 bits! confirm column parity */\r
- else if (rows == 10)\r
- {\r
- /* We need to make sure our 4 bits of parity are correct and we have a stop bit */\r
- if (BitStream[i] == parity[0] && BitStream[i+1] == parity[1] &&\r
- BitStream[i+2] == parity[2] && BitStream[i+3] == parity[3] &&\r
- BitStream[i+4] == 0)\r
- {\r
- /* Sweet! */\r
- PrintToScrollback("EM410x Tag ID: %s", id);\r
-\r
- /* Stop any loops */\r
- go = 0;\r
- return;\r
- }\r
-\r
- /* Crap! Incorrect parity or no stop bit, start all over */\r
- else\r
- {\r
- rows = header = 0;\r
-\r
- /* Go back 59 bits (9 header bits + 10 rows at 4+1 parity) */\r
- i -= 59;\r
- }\r
- }\r
-\r
- /* Step 1: get our header */\r
- else if (header < 9)\r
- {\r
- /* Need 9 consecutive 1's */\r
- if (BitStream[i] == 1)\r
- header++;\r
-\r
- /* We don't have a header, not enough consecutive 1 bits */\r
- else\r
- header = 0;\r
- }\r
- }\r
-\r
- /* if we've already retested after flipping bits, return */\r
- if (retested++)\r
- return;\r
-\r
- /* if this didn't work, try flipping bits */\r
- for (i = 0; i < bit2idx; i++)\r
- BitStream[i] ^= 1;\r
-\r
- goto retest;\r
-}\r
-\r
-/* emulate an EM410X tag\r
- * Format:\r
- * 1111 1111 1 <-- standard non-repeatable header\r
- * XXXX [row parity bit] <-- 10 rows of 5 bits for our 40 bit tag ID\r
- * ....\r
- * CCCC <-- each bit here is parity for the 10 bits above in corresponding column\r
- * 0 <-- stop bit, end of tag\r
- */\r
-static void CmdEM410xsim(char *str)\r
-{\r
- int i, n, j, h, binary[4], parity[4];\r
- char *s = "0";\r
-\r
- /* clock is 64 in EM410x tags */\r
- int clock = 64;\r
-\r
- /* clear our graph */\r
- CmdClearGraph(0);\r
-\r
- /* write it out a few times */\r
- for (h = 0; h < 4; h++)\r
- {\r
- /* write 9 start bits */\r
- for (i = 0; i < 9; i++)\r
- CmdAppendGraph(0, clock, 1);\r
-\r
- /* for each hex char */\r
- parity[0] = parity[1] = parity[2] = parity[3] = 0;\r
- for (i = 0; i < 10; i++)\r
- {\r
- /* read each hex char */\r
- sscanf(&str[i], "%1x", &n);\r
- for (j = 3; j >= 0; j--, n/= 2)\r
- binary[j] = n % 2;\r
-\r
- /* append each bit */\r
- CmdAppendGraph(0, clock, binary[0]);\r
- CmdAppendGraph(0, clock, binary[1]);\r
- CmdAppendGraph(0, clock, binary[2]);\r
- CmdAppendGraph(0, clock, binary[3]);\r
-\r
- /* append parity bit */\r
- CmdAppendGraph(0, clock, binary[0] ^ binary[1] ^ binary[2] ^ binary[3]);\r
-\r
- /* keep track of column parity */\r
- parity[0] ^= binary[0];\r
- parity[1] ^= binary[1];\r
- parity[2] ^= binary[2];\r
- parity[3] ^= binary[3];\r
- }\r
-\r
- /* parity columns */\r
- CmdAppendGraph(0, clock, parity[0]);\r
- CmdAppendGraph(0, clock, parity[1]);\r
- CmdAppendGraph(0, clock, parity[2]);\r
- CmdAppendGraph(0, clock, parity[3]);\r
-\r
- /* stop bit */\r
- CmdAppendGraph(0, clock, 0);\r
- }\r
-\r
- /* modulate that biatch */\r
- Cmdmanchestermod(s);\r
-\r
- /* booyah! */\r
- RepaintGraphWindow();\r
-\r
- CmdLosim(s);\r
-}\r
-\r
-static void ChkBitstream(char *str)\r
-{\r
- int i;\r
-\r
- /* convert to bitstream if necessary */\r
- for (i = 0; i < (int)(GraphTraceLen / 2); i++)\r
- {\r
- if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0)\r
- {\r
- Cmdbitstream(str);\r
- break;\r
- }\r
- }\r
-}\r
-\r
-static void CmdLosim(char *str)\r
-{\r
- int i;\r
-\r
- /* convert to bitstream if necessary */\r
- ChkBitstream(str);\r
-\r
- for (i = 0; i < GraphTraceLen; i += 48) {\r
- UsbCommand c;\r
- int j;\r
- for(j = 0; j < 48; j++) {\r
- c.d.asBytes[j] = GraphBuffer[i+j];\r
- }\r
- c.cmd = CMD_DOWNLOADED_SIM_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- }\r
-\r
- UsbCommand c;\r
- c.cmd = CMD_SIMULATE_TAG_125K;\r
- c.ext1 = GraphTraceLen;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdLosimBidir(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_LF_SIMULATE_BIDIR;\r
- c.ext1 = 47; /* Set ADC to twice the carrier for a slight supersampling */\r
- c.ext2 = 384;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdLoread(char *str)\r
-{\r
- UsbCommand c;\r
- // 'h' means higher-low-frequency, 134 kHz\r
- if(*str == 'h') {\r
- c.ext1 = 1;\r
- } else if (*str == '\0') {\r
- c.ext1 = 0;\r
- } else {\r
- PrintToScrollback("use 'loread' or 'loread h'");\r
- return;\r
- }\r
- c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_125K;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdDetectReader(char *str)\r
-{\r
- UsbCommand c;\r
- // 'l' means LF - 125/134 kHz\r
- if(*str == 'l') {\r
- c.ext1 = 1;\r
- } else if (*str == 'h') {\r
- c.ext1 = 2;\r
- } else if (*str != '\0') {\r
- PrintToScrollback("use 'detectreader' or 'detectreader l' or 'detectreader h'");\r
- return;\r
- }\r
- c.cmd = CMD_LISTEN_READER_FIELD;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-/* send a command before reading */\r
-static void CmdLoCommandRead(char *str)\r
-{\r
- static char dummy[3];\r
-\r
- dummy[0]= ' ';\r
-\r
- UsbCommand c;\r
- c.cmd = CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K;\r
- sscanf(str, "%i %i %i %s %s", &c.ext1, &c.ext2, &c.ext3, (char *) &c.d.asBytes,(char *) &dummy+1);\r
- // in case they specified 'h'\r
- strcpy((char *)&c.d.asBytes + strlen((char *)c.d.asBytes), dummy);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdLosamples(char *str)\r
-{\r
- int cnt = 0;\r
- int i;\r
- int n;\r
-\r
- n=atoi(str);\r
- if (n==0) n=128;\r
- if (n>16000) n=16000;\r
-\r
- for(i = 0; i < n; i += 12) {\r
- UsbCommand c;\r
- c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- ReceiveCommand(&c);\r
- if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
- if (!go)\r
- PrintToScrollback("bad resp");\r
- return;\r
- }\r
- int j;\r
- for(j = 0; j < 48; j++) {\r
- GraphBuffer[cnt++] = ((int)c.d.asBytes[j]) - 128;\r
- }\r
- }\r
- GraphTraceLen = n*4;\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdBitsamples(char *str)\r
-{\r
- int cnt = 0;\r
- int i;\r
- int n;\r
-\r
- n = 3072;\r
- for(i = 0; i < n; i += 12) {\r
- UsbCommand c;\r
- c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- ReceiveCommand(&c);\r
- if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
- PrintToScrollback("bad resp");\r
- return;\r
- }\r
- int j, k;\r
- for(j = 0; j < 48; j++) {\r
- for(k = 0; k < 8; k++) {\r
- if(c.d.asBytes[j] & (1 << (7 - k))) {\r
- GraphBuffer[cnt++] = 1;\r
- } else {\r
- GraphBuffer[cnt++] = 0;\r
- }\r
- }\r
- }\r
- }\r
- GraphTraceLen = cnt;\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdHisamples(char *str)\r
-{\r
- int cnt = 0;\r
- int i;\r
- int n;\r
- n = 1000;\r
- for(i = 0; i < n; i += 12) {\r
- UsbCommand c;\r
- c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- ReceiveCommand(&c);\r
- if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
- PrintToScrollback("bad resp");\r
- return;\r
- }\r
- int j;\r
- for(j = 0; j < 48; j++) {\r
- GraphBuffer[cnt++] = (int)((BYTE)c.d.asBytes[j]);\r
- }\r
- }\r
- GraphTraceLen = n*4;\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-static int CmdHisamplest(char *str, int nrlow)\r
-{\r
- int cnt = 0;\r
- int t1, t2;\r
- int i;\r
- int n;\r
- int hasbeennull;\r
- int show;\r
-\r
-\r
- n = 1000;\r
- hasbeennull = 0;\r
- for(i = 0; i < n; i += 12) {\r
- UsbCommand c;\r
- c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- ReceiveCommand(&c);\r
- if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
- PrintToScrollback("bad resp");\r
- return 0;\r
- }\r
- int j;\r
- for(j = 0; j < 48; j++) {\r
- t2 = (int)((BYTE)c.d.asBytes[j]);\r
- if((t2 ^ 0xC0) & 0xC0) { hasbeennull++; }\r
-\r
- show = 0;\r
- switch(show) {\r
- case 0:\r
- // combined\r
- t1 = (t2 & 0x80) ^ (t2 & 0x20);\r
- t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x20);\r
- break;\r
-\r
- case 1:\r
- // only reader\r
- t1 = (t2 & 0x80);\r
- t2 = ((t2 << 1) & 0x80);\r
- break;\r
-\r
- case 2:\r
- // only tag\r
- t1 = (t2 & 0x20);\r
- t2 = ((t2 << 1) & 0x20);\r
- break;\r
-\r
- case 3:\r
- // both, but tag with other algorithm\r
- t1 = (t2 & 0x80) ^ (t2 & 0x08);\r
- t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x08);\r
- break;\r
- }\r
-\r
- GraphBuffer[cnt++] = t1;\r
- GraphBuffer[cnt++] = t2;\r
- }\r
- }\r
- GraphTraceLen = n*4;\r
-// 1130\r
- if(hasbeennull>nrlow || nrlow==0) {\r
- PrintToScrollback("hasbeennull=%d", hasbeennull);\r
- return 1;\r
- }\r
- else {\r
- return 0;\r
- }\r
-}\r
-\r
-\r
-static void CmdHexsamples(char *str)\r
-{\r
- int i;\r
- int n;\r
- int requested = atoi(str);\r
- int delivered = 0;\r
-\r
- if(atoi(str) == 0) {\r
- n = 12;\r
- requested = 12;\r
- } else {\r
- n = atoi(str)/4;\r
- }\r
-\r
- for(i = 0; i < n; i += 12) {\r
- UsbCommand c;\r
- c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- ReceiveCommand(&c);\r
- if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
- PrintToScrollback("bad resp");\r
- return;\r
- }\r
- int j;\r
- for(j = 0; j < 48; j += 8) {\r
- PrintToScrollback("%02x %02x %02x %02x %02x %02x %02x %02x",\r
- c.d.asBytes[j+0],\r
- c.d.asBytes[j+1],\r
- c.d.asBytes[j+2],\r
- c.d.asBytes[j+3],\r
- c.d.asBytes[j+4],\r
- c.d.asBytes[j+5],\r
- c.d.asBytes[j+6],\r
- c.d.asBytes[j+7],\r
- c.d.asBytes[j+8]\r
- );\r
- delivered += 8;\r
- if(delivered >= requested)\r
- break;\r
- }\r
- if(delivered >= requested)\r
- break;\r
- }\r
-}\r
-\r
-static void CmdHisampless(char *str)\r
-{\r
- int cnt = 0;\r
- int i;\r
- int n;\r
-\r
- if(atoi(str) == 0) {\r
- n = 1000;\r
- } else {\r
- n = atoi(str)/4;\r
- }\r
-\r
- for(i = 0; i < n; i += 12) {\r
- UsbCommand c;\r
- c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
- c.ext1 = i;\r
- SendCommand(&c, FALSE);\r
- ReceiveCommand(&c);\r
- if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
- PrintToScrollback("bad resp");\r
- return;\r
- }\r
- int j;\r
- for(j = 0; j < 48; j++) {\r
- GraphBuffer[cnt++] = (int)((signed char)c.d.asBytes[j]);\r
- }\r
- }\r
- GraphTraceLen = cnt;\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-static WORD Iso15693Crc(BYTE *v, int n)\r
-{\r
- DWORD reg;\r
- int i, j;\r
-\r
- reg = 0xffff;\r
- for(i = 0; i < n; i++) {\r
- reg = reg ^ ((DWORD)v[i]);\r
- for (j = 0; j < 8; j++) {\r
- if (reg & 0x0001) {\r
- reg = (reg >> 1) ^ 0x8408;\r
- } else {\r
- reg = (reg >> 1);\r
- }\r
- }\r
- }\r
-\r
- return (WORD)~reg;\r
-}\r
-\r
-static void CmdHi14bdemod(char *str)\r
-{\r
- int i, j, iold;\r
- int isum, qsum;\r
- int outOfWeakAt;\r
- BOOL negateI, negateQ;\r
-\r
- BYTE data[256];\r
- int dataLen=0;\r
-\r
- // As received, the samples are pairs, correlations against I and Q\r
- // square waves. So estimate angle of initial carrier (or just\r
- // quadrant, actually), and then do the demod.\r
-\r
- // First, estimate where the tag starts modulating.\r
- for(i = 0; i < GraphTraceLen; i += 2) {\r
- if(abs(GraphBuffer[i]) + abs(GraphBuffer[i+1]) > 40) {\r
- break;\r
- }\r
- }\r
- if(i >= GraphTraceLen) {\r
- PrintToScrollback("too weak to sync");\r
- return;\r
- }\r
- PrintToScrollback("out of weak at %d", i);\r
- outOfWeakAt = i;\r
-\r
- // Now, estimate the phase in the initial modulation of the tag\r
- isum = 0;\r
- qsum = 0;\r
- for(; i < (outOfWeakAt + 16); i += 2) {\r
- isum += GraphBuffer[i+0];\r
- qsum += GraphBuffer[i+1];\r
- }\r
- negateI = (isum < 0);\r
- negateQ = (qsum < 0);\r
-\r
- // Turn the correlation pairs into soft decisions on the bit.\r
- j = 0;\r
- for(i = 0; i < GraphTraceLen/2; i++) {\r
- int si = GraphBuffer[j];\r
- int sq = GraphBuffer[j+1];\r
- if(negateI) si = -si;\r
- if(negateQ) sq = -sq;\r
- GraphBuffer[i] = si + sq;\r
- j += 2;\r
- }\r
- GraphTraceLen = i;\r
-\r
- i = outOfWeakAt/2;\r
- while(GraphBuffer[i] > 0 && i < GraphTraceLen)\r
- i++;\r
- if(i >= GraphTraceLen) goto demodError;\r
-\r
- iold = i;\r
- while(GraphBuffer[i] < 0 && i < GraphTraceLen)\r
- i++;\r
- if(i >= GraphTraceLen) goto demodError;\r
- if((i - iold) > 23) goto demodError;\r
-\r
- PrintToScrollback("make it to demod loop");\r
-\r
- for(;;) {\r
- iold = i;\r
- while(GraphBuffer[i] >= 0 && i < GraphTraceLen)\r
- i++;\r
- if(i >= GraphTraceLen) goto demodError;\r
- if((i - iold) > 6) goto demodError;\r
-\r
- WORD shiftReg = 0;\r
- if(i + 20 >= GraphTraceLen) goto demodError;\r
-\r
- for(j = 0; j < 10; j++) {\r
- int soft = GraphBuffer[i] + GraphBuffer[i+1];\r
-\r
- if(abs(soft) < ((abs(isum) + abs(qsum))/20)) {\r
- PrintToScrollback("weak bit");\r
- }\r
-\r
- shiftReg >>= 1;\r
- if(GraphBuffer[i] + GraphBuffer[i+1] >= 0) {\r
- shiftReg |= 0x200;\r
- }\r
-\r
- i+= 2;\r
- }\r
-\r
- if( (shiftReg & 0x200) &&\r
- !(shiftReg & 0x001))\r
- {\r
- // valid data byte, start and stop bits okay\r
- PrintToScrollback(" %02x", (shiftReg >> 1) & 0xff);\r
- data[dataLen++] = (shiftReg >> 1) & 0xff;\r
- if(dataLen >= sizeof(data)) {\r
- return;\r
- }\r
- } else if(shiftReg == 0x000) {\r
- // this is EOF\r
- break;\r
- } else {\r
- goto demodError;\r
- }\r
- }\r
-\r
- BYTE first, second;\r
- ComputeCrc14443(CRC_14443_B, data, dataLen-2, &first, &second);\r
- PrintToScrollback("CRC: %02x %02x (%s)\n", first, second,\r
- (first == data[dataLen-2] && second == data[dataLen-1]) ?\r
- "ok" : "****FAIL****");\r
-\r
- RepaintGraphWindow();\r
- return;\r
-\r
-demodError:\r
- PrintToScrollback("demod error");\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdHi14list(char *str)\r
-{\r
- BYTE got[960];\r
- GetFromBigBuf(got, sizeof(got));\r
-\r
- PrintToScrollback("recorded activity:");\r
- PrintToScrollback(" time :rssi: who bytes");\r
- PrintToScrollback("---------+----+----+-----------");\r
-\r
- int i = 0;\r
- int prev = -1;\r
-\r
- for(;;) {\r
- if(i >= 900) {\r
- break;\r
- }\r
-\r
- BOOL isResponse;\r
- int timestamp = *((DWORD *)(got+i));\r
- if(timestamp & 0x80000000) {\r
- timestamp &= 0x7fffffff;\r
- isResponse = 1;\r
- } else {\r
- isResponse = 0;\r
- }\r
- int metric = *((DWORD *)(got+i+4));\r
-\r
- int len = got[i+8];\r
-\r
- if(len > 100) {\r
- break;\r
- }\r
- if(i + len >= 900) {\r
- break;\r
- }\r
-\r
- BYTE *frame = (got+i+9);\r
-\r
- char line[1000] = "";\r
- int j;\r
- for(j = 0; j < len; j++) {\r
- sprintf(line+(j*3), "%02x ", frame[j]);\r
- }\r
-\r
- char *crc;\r
- if(len > 2) {\r
- BYTE b1, b2;\r
- ComputeCrc14443(CRC_14443_B, frame, len-2, &b1, &b2);\r
- if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
- crc = "**FAIL CRC**";\r
- } else {\r
- crc = "";\r
- }\r
- } else {\r
- crc = "(SHORT)";\r
- }\r
-\r
- char metricString[100];\r
- if(isResponse) {\r
- sprintf(metricString, "%3d", metric);\r
- } else {\r
- strcpy(metricString, " ");\r
- }\r
-\r
- PrintToScrollback(" +%7d: %s: %s %s %s",\r
- (prev < 0 ? 0 : timestamp - prev),\r
- metricString,\r
- (isResponse ? "TAG" : " "), line, crc);\r
-\r
- prev = timestamp;\r
- i += (len + 9);\r
- }\r
-}\r
-\r
-static void CmdHi14alist(char *str)\r
-{\r
- BYTE got[1920];\r
- GetFromBigBuf(got, sizeof(got));\r
-\r
- PrintToScrollback("recorded activity:");\r
- PrintToScrollback(" ETU :rssi: who bytes");\r
- PrintToScrollback("---------+----+----+-----------");\r
-\r
- int i = 0;\r
- int prev = -1;\r
-\r
- for(;;) {\r
- if(i >= 1900) {\r
- break;\r
- }\r
-\r
- BOOL isResponse;\r
- int timestamp = *((DWORD *)(got+i));\r
- if(timestamp & 0x80000000) {\r
- timestamp &= 0x7fffffff;\r
- isResponse = 1;\r
- } else {\r
- isResponse = 0;\r
- }\r
-\r
- int metric = 0;\r
- int parityBits = *((DWORD *)(got+i+4));\r
- // 4 bytes of additional information...\r
- // maximum of 32 additional parity bit information\r
- //\r
- // TODO:\r
- // at each quarter bit period we can send power level (16 levels)\r
- // or each half bit period in 256 levels.\r
-\r
-\r
- int len = got[i+8];\r
-\r
- if(len > 100) {\r
- break;\r
- }\r
- if(i + len >= 1900) {\r
- break;\r
- }\r
-\r
- BYTE *frame = (got+i+9);\r
-\r
- // Break and stick with current result if buffer was not completely full\r
- if(frame[0] == 0x44 && frame[1] == 0x44 && frame[3] == 0x44) { break; }\r
-\r
- char line[1000] = "";\r
- int j;\r
- for(j = 0; j < len; j++) {\r
- int oddparity = 0x01;\r
- int k;\r
-\r
- for(k=0;k<8;k++) {\r
- oddparity ^= (((frame[j] & 0xFF) >> k) & 0x01);\r
- }\r
-\r
- //if((parityBits >> (len - j - 1)) & 0x01) {\r
- if(isResponse && (oddparity != ((parityBits >> (len - j - 1)) & 0x01))) {\r
- sprintf(line+(j*4), "%02x! ", frame[j]);\r
- }\r
- else {\r
- sprintf(line+(j*4), "%02x ", frame[j]);\r
- }\r
- }\r
-\r
- char *crc;\r
- crc = "";\r
- if(len > 2) {\r
- BYTE b1, b2;\r
- for(j = 0; j < (len - 1); j++) {\r
- // gives problems... search for the reason..\r
- /*if(frame[j] == 0xAA) {\r
- switch(frame[j+1]) {\r
- case 0x01:\r
- crc = "[1] Two drops close after each other";\r
- break;\r
- case 0x02:\r
- crc = "[2] Potential SOC with a drop in second half of bitperiod";\r
- break;\r
- case 0x03:\r
- crc = "[3] Segment Z after segment X is not possible";\r
- break;\r
- case 0x04:\r
- crc = "[4] Parity bit of a fully received byte was wrong";\r
- break;\r
- default:\r
- crc = "[?] Unknown error";\r
- break;\r
- }\r
- break;\r
- }*/\r
- }\r
-\r
- if(strlen(crc)==0) {\r
- ComputeCrc14443(CRC_14443_A, frame, len-2, &b1, &b2);\r
- if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
- crc = (isResponse & (len < 6)) ? "" : " !crc";\r
- } else {\r
- crc = "";\r
- }\r
- }\r
- } else {\r
- crc = ""; // SHORT\r
- }\r
-\r
- char metricString[100];\r
- if(isResponse) {\r
- sprintf(metricString, "%3d", metric);\r
- } else {\r
- strcpy(metricString, " ");\r
- }\r
-\r
- PrintToScrollback(" +%7d: %s: %s %s %s",\r
- (prev < 0 ? 0 : (timestamp - prev)),\r
- metricString,\r
- (isResponse ? "TAG" : " "), line, crc);\r
-\r
- prev = timestamp;\r
- i += (len + 9);\r
- }\r
- CommandFinished = 1;\r
-}\r
-\r
-static void CmdHi15demod(char *str)\r
-{\r
- // The sampling rate is 106.353 ksps/s, for T = 18.8 us\r
-\r
- // SOF defined as\r
- // 1) Unmodulated time of 56.64us\r
- // 2) 24 pulses of 423.75khz\r
- // 3) logic '1' (unmodulated for 18.88us followed by 8 pulses of 423.75khz)\r
-\r
- static const int FrameSOF[] = {\r
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- -1, -1, -1, -1,\r
- -1, -1, -1, -1,\r
- 1, 1, 1, 1,\r
- 1, 1, 1, 1\r
- };\r
- static const int Logic0[] = {\r
- 1, 1, 1, 1,\r
- 1, 1, 1, 1,\r
- -1, -1, -1, -1,\r
- -1, -1, -1, -1\r
- };\r
- static const int Logic1[] = {\r
- -1, -1, -1, -1,\r
- -1, -1, -1, -1,\r
- 1, 1, 1, 1,\r
- 1, 1, 1, 1\r
- };\r
-\r
- // EOF defined as\r
- // 1) logic '0' (8 pulses of 423.75khz followed by unmodulated for 18.88us)\r
- // 2) 24 pulses of 423.75khz\r
- // 3) Unmodulated time of 56.64us\r
-\r
- static const int FrameEOF[] = {\r
- 1, 1, 1, 1,\r
- 1, 1, 1, 1,\r
- -1, -1, -1, -1,\r
- -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1\r
- };\r
-\r
- int i, j;\r
- int max = 0, maxPos;\r
-\r
- int skip = 4;\r
-\r
- if(GraphTraceLen < 1000) return;\r
-\r
- // First, correlate for SOF\r
- for(i = 0; i < 100; i++) {\r
- int corr = 0;\r
- for(j = 0; j < arraylen(FrameSOF); j += skip) {\r
- corr += FrameSOF[j]*GraphBuffer[i+(j/skip)];\r
- }\r
- if(corr > max) {\r
- max = corr;\r
- maxPos = i;\r
- }\r
- }\r
- PrintToScrollback("SOF at %d, correlation %d", maxPos,\r
- max/(arraylen(FrameSOF)/skip));\r
-\r
- i = maxPos + arraylen(FrameSOF)/skip;\r
- int k = 0;\r
- BYTE outBuf[20];\r
- memset(outBuf, 0, sizeof(outBuf));\r
- BYTE mask = 0x01;\r
- for(;;) {\r
- int corr0 = 0, corr1 = 0, corrEOF = 0;\r
- for(j = 0; j < arraylen(Logic0); j += skip) {\r
- corr0 += Logic0[j]*GraphBuffer[i+(j/skip)];\r
- }\r
- for(j = 0; j < arraylen(Logic1); j += skip) {\r
- corr1 += Logic1[j]*GraphBuffer[i+(j/skip)];\r
- }\r
- for(j = 0; j < arraylen(FrameEOF); j += skip) {\r
- corrEOF += FrameEOF[j]*GraphBuffer[i+(j/skip)];\r
- }\r
- // Even things out by the length of the target waveform.\r
- corr0 *= 4;\r
- corr1 *= 4;\r
-\r
- if(corrEOF > corr1 && corrEOF > corr0) {\r
- PrintToScrollback("EOF at %d", i);\r
- break;\r
- } else if(corr1 > corr0) {\r
- i += arraylen(Logic1)/skip;\r
- outBuf[k] |= mask;\r
- } else {\r
- i += arraylen(Logic0)/skip;\r
- }\r
- mask <<= 1;\r
- if(mask == 0) {\r
- k++;\r
- mask = 0x01;\r
- }\r
- if((i+(int)arraylen(FrameEOF)) >= GraphTraceLen) {\r
- PrintToScrollback("ran off end!");\r
- break;\r
- }\r
- }\r
- if(mask != 0x01) {\r
- PrintToScrollback("error, uneven octet! (discard extra bits!)");\r
- PrintToScrollback(" mask=%02x", mask);\r
- }\r
- PrintToScrollback("%d octets", k);\r
-\r
- for(i = 0; i < k; i++) {\r
- PrintToScrollback("# %2d: %02x ", i, outBuf[i]);\r
- }\r
- PrintToScrollback("CRC=%04x", Iso15693Crc(outBuf, k-2));\r
-}\r
-\r
-static void CmdFSKdemod(char *cmdline)\r
-{\r
- static const int LowTone[] = {\r
- 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, -1, -1, -1, -1, -1\r
- };\r
- static const int HighTone[] = {\r
- 1, 1, 1, 1, 1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
- };\r
-\r
- int lowLen = sizeof(LowTone)/sizeof(int);\r
- int highLen = sizeof(HighTone)/sizeof(int);\r
- int convLen = (highLen>lowLen)?highLen:lowLen;\r
- DWORD hi = 0, lo = 0;\r
-\r
- int i, j;\r
- int minMark=0, maxMark=0;\r
-\r
- for(i = 0; i < GraphTraceLen - convLen; i++) {\r
- int lowSum = 0, highSum = 0;\r
-\r
- for(j = 0; j < lowLen; j++) {\r
- lowSum += LowTone[j]*GraphBuffer[i+j];\r
- }\r
- for(j = 0; j < highLen; j++) {\r
- highSum += HighTone[j]*GraphBuffer[i+j];\r
- }\r
- lowSum = abs((100*lowSum) / lowLen);\r
- highSum = abs((100*highSum) / highLen);\r
- GraphBuffer[i] = (highSum << 16) | lowSum;\r
- }\r
-\r
- for(i = 0; i < GraphTraceLen - convLen - 16; i++) {\r
- int j;\r
- int lowTot = 0, highTot = 0;\r
- // 10 and 8 are f_s divided by f_l and f_h, rounded\r
- for(j = 0; j < 10; j++) {\r
- lowTot += (GraphBuffer[i+j] & 0xffff);\r
- }\r
- for(j = 0; j < 8; j++) {\r
- highTot += (GraphBuffer[i+j] >> 16);\r
- }\r
- GraphBuffer[i] = lowTot - highTot;\r
- if (GraphBuffer[i]>maxMark) maxMark=GraphBuffer[i];\r
- if (GraphBuffer[i]<minMark) minMark=GraphBuffer[i];\r
- }\r
-\r
- GraphTraceLen -= (convLen + 16);\r
-\r
- RepaintGraphWindow();\r
-\r
- // Find bit-sync (3 lo followed by 3 high)\r
- int max = 0, maxPos = 0;\r
- for(i = 0; i < 6000; i++) {\r
- int dec = 0;\r
- for(j = 0; j < 3*lowLen; j++) {\r
- dec -= GraphBuffer[i+j];\r
- }\r
- for(; j < 3*(lowLen + highLen ); j++) {\r
- dec += GraphBuffer[i+j];\r
- }\r
- if(dec > max) {\r
- max = dec;\r
- maxPos = i;\r
- }\r
- }\r
-\r
- // place start of bit sync marker in graph\r
- GraphBuffer[maxPos] = maxMark;\r
- GraphBuffer[maxPos+1] = minMark;\r
-\r
- maxPos += j;\r
-\r
- // place end of bit sync marker in graph\r
- GraphBuffer[maxPos] = maxMark;\r
- GraphBuffer[maxPos+1] = minMark;\r
-\r
- PrintToScrollback("actual data bits start at sample %d", maxPos);\r
- PrintToScrollback("length %d/%d", highLen, lowLen);\r
-\r
- BYTE bits[46];\r
- bits[sizeof(bits)-1] = '\0';\r
-\r
- // find bit pairs and manchester decode them\r
- for(i = 0; i < arraylen(bits)-1; i++) {\r
- int dec = 0;\r
- for(j = 0; j < lowLen; j++) {\r
- dec -= GraphBuffer[maxPos+j];\r
- }\r
- for(; j < lowLen + highLen; j++) {\r
- dec += GraphBuffer[maxPos+j];\r
- }\r
- maxPos += j;\r
- // place inter bit marker in graph\r
- GraphBuffer[maxPos] = maxMark;\r
- GraphBuffer[maxPos+1] = minMark;\r
-\r
- // hi and lo form a 64 bit pair\r
- hi = (hi<<1)|(lo>>31);\r
- lo = (lo<<1);\r
- // store decoded bit as binary (in hi/lo) and text (in bits[])\r
- if(dec<0) {\r
- bits[i] = '1';\r
- lo|=1;\r
- } else {\r
- bits[i] = '0';\r
- }\r
- }\r
- PrintToScrollback("bits: '%s'", bits);\r
- PrintToScrollback("hex: %08x %08x", hi, lo);\r
-}\r
-\r
-// read a TI tag and return its ID\r
-static void CmdTIRead(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_READ_TI_TYPE;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-// write new data to a r/w TI tag\r
-static void CmdTIWrite(char *str)\r
-{\r
- UsbCommand c;\r
- int res=0;\r
-\r
- c.cmd = CMD_WRITE_TI_TYPE;\r
- res = sscanf(str, "0x%x 0x%x 0x%x ", &c.ext1, &c.ext2, &c.ext3);\r
- if (res == 2) c.ext3=0;\r
- if (res<2)\r
- PrintToScrollback("Please specify the data as two hex strings, optionally the CRC as a third");\r
- else\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdTIDemod(char *cmdline)\r
-{\r
- /* MATLAB as follows:\r
-f_s = 2000000; % sampling frequency\r
-f_l = 123200; % low FSK tone\r
-f_h = 134200; % high FSK tone\r
-\r
-T_l = 119e-6; % low bit duration\r
-T_h = 130e-6; % high bit duration\r
-\r
-l = 2*pi*ones(1, floor(f_s*T_l))*(f_l/f_s);\r
-h = 2*pi*ones(1, floor(f_s*T_h))*(f_h/f_s);\r
-\r
-l = sign(sin(cumsum(l)));\r
-h = sign(sin(cumsum(h)));\r
- */\r
-\r
-// 2M*16/134.2k = 238\r
- static const int LowTone[] = {\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1\r
- };\r
-// 2M*16/123.2k = 260\r
- static const int HighTone[] = {\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1\r
- };\r
- int lowLen = sizeof(LowTone)/sizeof(int);\r
- int highLen = sizeof(HighTone)/sizeof(int);\r
- int convLen = (highLen>lowLen)?highLen:lowLen;\r
- WORD crc;\r
- int i, j, TagType;\r
- int lowSum = 0, highSum = 0;;\r
- int lowTot = 0, highTot = 0;\r
-\r
- for(i = 0; i < GraphTraceLen - convLen; i++) {\r
- lowSum = 0;\r
- highSum = 0;;\r
-\r
- for(j = 0; j < lowLen; j++) {\r
- lowSum += LowTone[j]*GraphBuffer[i+j];\r
- }\r
- for(j = 0; j < highLen; j++) {\r
- highSum += HighTone[j]*GraphBuffer[i+j];\r
- }\r
- lowSum = abs((100*lowSum) / lowLen);\r
- highSum = abs((100*highSum) / highLen);\r
- lowSum = (lowSum<0)?-lowSum:lowSum;\r
- highSum = (highSum<0)?-highSum:highSum;\r
-\r
- GraphBuffer[i] = (highSum << 16) | lowSum;\r
- }\r
-\r
- for(i = 0; i < GraphTraceLen - convLen - 16; i++) {\r
- lowTot = 0;\r
- highTot = 0;\r
- // 16 and 15 are f_s divided by f_l and f_h, rounded\r
- for(j = 0; j < 16; j++) {\r
- lowTot += (GraphBuffer[i+j] & 0xffff);\r
- }\r
- for(j = 0; j < 15; j++) {\r
- highTot += (GraphBuffer[i+j] >> 16);\r
- }\r
- GraphBuffer[i] = lowTot - highTot;\r
- }\r
-\r
- GraphTraceLen -= (convLen + 16);\r
-\r
- RepaintGraphWindow();\r
-\r
- // TI tag data format is 16 prebits, 8 start bits, 64 data bits,\r
- // 16 crc CCITT bits, 8 stop bits, 15 end bits\r
-\r
- // the 16 prebits are always low\r
- // the 8 start and stop bits of a tag must match\r
- // the start/stop prebits of a ro tag are 01111110\r
- // the start/stop prebits of a rw tag are 11111110\r
- // the 15 end bits of a ro tag are all low\r
- // the 15 end bits of a rw tag match bits 15-1 of the data bits\r
-\r
- // Okay, so now we have unsliced soft decisions;\r
- // find bit-sync, and then get some bits.\r
- // look for 17 low bits followed by 6 highs (common pattern for ro and rw tags)\r
- int max = 0, maxPos = 0;\r
- for(i = 0; i < 6000; i++) {\r
- int j;\r
- int dec = 0;\r
- // searching 17 consecutive lows\r
- for(j = 0; j < 17*lowLen; j++) {\r
- dec -= GraphBuffer[i+j];\r
- }\r
- // searching 7 consecutive highs\r
- for(; j < 17*lowLen + 6*highLen; j++) {\r
- dec += GraphBuffer[i+j];\r
- }\r
- if(dec > max) {\r
- max = dec;\r
- maxPos = i;\r
- }\r
- }\r
-\r
- // place a marker in the buffer to visually aid location\r
- // of the start of sync\r
- GraphBuffer[maxPos] = 800;\r
- GraphBuffer[maxPos+1] = -800;\r
-\r
- // advance pointer to start of actual data stream (after 16 pre and 8 start bits)\r
- maxPos += 17*lowLen;\r
- maxPos += 6*highLen;\r
-\r
- // place a marker in the buffer to visually aid location\r
- // of the end of sync\r
- GraphBuffer[maxPos] = 800;\r
- GraphBuffer[maxPos+1] = -800;\r
-\r
- PrintToScrollback("actual data bits start at sample %d", maxPos);\r
-\r
- PrintToScrollback("length %d/%d", highLen, lowLen);\r
-\r
- BYTE bits[1+64+16+8+16];\r
- bits[sizeof(bits)-1] = '\0';\r
-\r
- DWORD shift3 = 0x7e000000, shift2 = 0, shift1 = 0, shift0 = 0;\r
-\r
- for(i = 0; i < arraylen(bits)-1; i++) {\r
- int high = 0;\r
- int low = 0;\r
- int j;\r
- for(j = 0; j < lowLen; j++) {\r
- low -= GraphBuffer[maxPos+j];\r
- }\r
- for(j = 0; j < highLen; j++) {\r
- high += GraphBuffer[maxPos+j];\r
- }\r
-\r
- if(high > low) {\r
- bits[i] = '1';\r
- maxPos += highLen;\r
- // bitstream arrives lsb first so shift right\r
- shift3 |= (1<<31);\r
- } else {\r
- bits[i] = '.';\r
- maxPos += lowLen;\r
- }\r
-\r
- // 128 bit right shift register\r
- shift0 = (shift0>>1) | (shift1 << 31);\r
- shift1 = (shift1>>1) | (shift2 << 31);\r
- shift2 = (shift2>>1) | (shift3 << 31);\r
- shift3 >>= 1;\r
-\r
- // place a marker in the buffer between bits to visually aid location\r
- GraphBuffer[maxPos] = 800;\r
- GraphBuffer[maxPos+1] = -800;\r
- }\r
- PrintToScrollback("Info: raw tag bits = %s", bits);\r
-\r
- TagType = (shift3>>8)&0xff;\r
- if ( TagType != ((shift0>>16)&0xff) ) {\r
- PrintToScrollback("Error: start and stop bits do not match!");\r
- return;\r
- }\r
- else if (TagType == 0x7e) {\r
- PrintToScrollback("Info: Readonly TI tag detected.");\r
- return;\r
- }\r
- else if (TagType == 0xfe) {\r
- PrintToScrollback("Info: Rewriteable TI tag detected.");\r
-\r
- // put 64 bit data into shift1 and shift0\r
- shift0 = (shift0>>24) | (shift1 << 8);\r
- shift1 = (shift1>>24) | (shift2 << 8);\r
-\r
- // align 16 bit crc into lower half of shift2\r
- shift2 = ((shift2>>24) | (shift3 << 8)) & 0x0ffff;\r
-\r
- // align 16 bit "end bits" or "ident" into lower half of shift3\r
- shift3 >>= 16;\r
-\r
- // only 15 bits compare, last bit of ident is not valid\r
- if ( (shift3^shift0)&0x7fff ) {\r
- PrintToScrollback("Error: Ident mismatch!");\r
- }\r
- // WARNING the order of the bytes in which we calc crc below needs checking\r
- // i'm 99% sure the crc algorithm is correct, but it may need to eat the\r
- // bytes in reverse or something\r
- // calculate CRC\r
- crc=0;\r
- crc = update_crc16(crc, (shift0)&0xff);\r
- crc = update_crc16(crc, (shift0>>8)&0xff);\r
- crc = update_crc16(crc, (shift0>>16)&0xff);\r
- crc = update_crc16(crc, (shift0>>24)&0xff);\r
- crc = update_crc16(crc, (shift1)&0xff);\r
- crc = update_crc16(crc, (shift1>>8)&0xff);\r
- crc = update_crc16(crc, (shift1>>16)&0xff);\r
- crc = update_crc16(crc, (shift1>>24)&0xff);\r
- PrintToScrollback("Info: Tag data = %08X%08X", shift1, shift0);\r
- if (crc != (shift2&0xffff)) {\r
- PrintToScrollback("Error: CRC mismatch, calculated %04X, got ^04X", crc, shift2&0xffff);\r
- } else {\r
- PrintToScrollback("Info: CRC %04X is good", crc);\r
- }\r
- }\r
- else {\r
- PrintToScrollback("Unknown tag type.");\r
- return;\r
- }\r
-}\r
-\r
-static void CmdNorm(char *str)\r
-{\r
- int i;\r
- int max = INT_MIN, min = INT_MAX;\r
- for(i = 10; i < GraphTraceLen; i++) {\r
- if(GraphBuffer[i] > max) {\r
- max = GraphBuffer[i];\r
- }\r
- if(GraphBuffer[i] < min) {\r
- min = GraphBuffer[i];\r
- }\r
- }\r
- if(max != min) {\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- GraphBuffer[i] = (GraphBuffer[i] - ((max + min)/2))*1000/\r
- (max - min);\r
- }\r
- }\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdAmp(char *str)\r
-{\r
- int i, rising, falling;\r
- int max = INT_MIN, min = INT_MAX;\r
- for(i = 10; i < GraphTraceLen; i++) {\r
- if(GraphBuffer[i] > max) {\r
- max = GraphBuffer[i];\r
- }\r
- if(GraphBuffer[i] < min) {\r
- min = GraphBuffer[i];\r
- }\r
- }\r
- if(max != min) {\r
- rising= falling= 0;\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- if(GraphBuffer[i+1] < GraphBuffer[i]) {\r
- if(rising) {\r
- GraphBuffer[i]= max;\r
- rising= 0;\r
- }\r
- falling= 1;\r
- }\r
- if(GraphBuffer[i+1] > GraphBuffer[i]) {\r
- if(falling) {\r
- GraphBuffer[i]= min;\r
- falling= 0;\r
- }\r
- rising= 1;\r
- }\r
- }\r
- }\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdDec(char *str)\r
-{\r
- int i;\r
- for(i = 0; i < (GraphTraceLen/2); i++) {\r
- GraphBuffer[i] = GraphBuffer[i*2];\r
- }\r
- GraphTraceLen /= 2;\r
- PrintToScrollback("decimated by 2");\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdHpf(char *str)\r
-{\r
- int i;\r
- int accum = 0;\r
- for(i = 10; i < GraphTraceLen; i++) {\r
- accum += GraphBuffer[i];\r
- }\r
- accum /= (GraphTraceLen - 10);\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- GraphBuffer[i] -= accum;\r
- }\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdZerocrossings(char *str)\r
-{\r
- int i;\r
- // Zero-crossings aren't meaningful unless the signal is zero-mean.\r
- CmdHpf("");\r
-\r
- int sign = 1;\r
- int zc = 0;\r
- int lastZc = 0;\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- if(GraphBuffer[i]*sign >= 0) {\r
- // No change in sign, reproduce the previous sample count.\r
- zc++;\r
- GraphBuffer[i] = lastZc;\r
- } else {\r
- // Change in sign, reset the sample count.\r
- sign = -sign;\r
- GraphBuffer[i] = lastZc;\r
- if(sign > 0) {\r
- lastZc = zc;\r
- zc = 0;\r
- }\r
- }\r
- }\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdThreshold(char *str)\r
-{\r
- int i;\r
- int threshold = atoi(str);\r
-\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- if(GraphBuffer[i]>= threshold)\r
- GraphBuffer[i]=1;\r
- else\r
- GraphBuffer[i]=-1;\r
- }\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdLtrim(char *str)\r
-{\r
- int i;\r
- int ds = atoi(str);\r
-\r
- for(i = ds; i < GraphTraceLen; i++) {\r
- GraphBuffer[i-ds] = GraphBuffer[i];\r
- }\r
- GraphTraceLen -= ds;\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdAutoCorr(char *str)\r
-{\r
- static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];\r
-\r
- int window = atoi(str);\r
-\r
- if(window == 0) {\r
- PrintToScrollback("needs a window");\r
- return;\r
- }\r
-\r
- if(window >= GraphTraceLen) {\r
- PrintToScrollback("window must be smaller than trace (%d samples)",\r
- GraphTraceLen);\r
- return;\r
- }\r
-\r
- PrintToScrollback("performing %d correlations", GraphTraceLen - window);\r
-\r
- int i;\r
- for(i = 0; i < GraphTraceLen - window; i++) {\r
- int sum = 0;\r
- int j;\r
- for(j = 0; j < window; j++) {\r
- sum += (GraphBuffer[j]*GraphBuffer[i+j]) / 256;\r
- }\r
- CorrelBuffer[i] = sum;\r
- }\r
- GraphTraceLen = GraphTraceLen - window;\r
- memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen*sizeof(int));\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdVchdemod(char *str)\r
-{\r
- // Is this the entire sync pattern, or does this also include some\r
- // data bits that happen to be the same everywhere? That would be\r
- // lovely to know.\r
- static const int SyncPattern[] = {\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
- };\r
-\r
- // So first, we correlate for the sync pattern, and mark that.\r
- int bestCorrel = 0, bestPos = 0;\r
- int i;\r
- // It does us no good to find the sync pattern, with fewer than\r
- // 2048 samples after it...\r
- for(i = 0; i < (GraphTraceLen-2048); i++) {\r
- int sum = 0;\r
- int j;\r
- for(j = 0; j < arraylen(SyncPattern); j++) {\r
- sum += GraphBuffer[i+j]*SyncPattern[j];\r
- }\r
- if(sum > bestCorrel) {\r
- bestCorrel = sum;\r
- bestPos = i;\r
- }\r
- }\r
- PrintToScrollback("best sync at %d [metric %d]", bestPos, bestCorrel);\r
-\r
- char bits[257];\r
- bits[256] = '\0';\r
-\r
- int worst = INT_MAX;\r
- int worstPos;\r
-\r
- for(i = 0; i < 2048; i += 8) {\r
- int sum = 0;\r
- int j;\r
- for(j = 0; j < 8; j++) {\r
- sum += GraphBuffer[bestPos+i+j];\r
- }\r
- if(sum < 0) {\r
- bits[i/8] = '.';\r
- } else {\r
- bits[i/8] = '1';\r
- }\r
- if(abs(sum) < worst) {\r
- worst = abs(sum);\r
- worstPos = i;\r
- }\r
- }\r
- PrintToScrollback("bits:");\r
- PrintToScrollback("%s", bits);\r
- PrintToScrollback("worst metric: %d at pos %d", worst, worstPos);\r
-\r
- if(strcmp(str, "clone")==0) {\r
- GraphTraceLen = 0;\r
- char *s;\r
- for(s = bits; *s; s++) {\r
- int j;\r
- for(j = 0; j < 16; j++) {\r
- GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0;\r
- }\r
- }\r
- RepaintGraphWindow();\r
- }\r
-}\r
-\r
-static void CmdIndalademod(char *str)\r
-{\r
- // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID\r
-\r
- int state = -1;\r
- int count = 0;\r
- int i, j;\r
- // worst case with GraphTraceLen=64000 is < 4096\r
- // under normal conditions it's < 2048\r
- BYTE rawbits[4096];\r
- int rawbit = 0;\r
- int worst = 0, worstPos = 0;\r
- PrintToScrollback("Expecting a bit less than %d raw bits", GraphTraceLen/32);\r
- for(i = 0; i < GraphTraceLen-1; i += 2) {\r
- count+=1;\r
- if((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) {\r
- if (state == 0) {\r
- for(j = 0; j < count - 8; j += 16) {\r
- rawbits[rawbit++] = 0;\r
- }\r
- if ((abs(count - j)) > worst) {\r
- worst = abs(count - j);\r
- worstPos = i;\r
- }\r
- }\r
- state = 1;\r
- count=0;\r
- } else if((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) {\r
- if (state == 1) {\r
- for(j = 0; j < count - 8; j += 16) {\r
- rawbits[rawbit++] = 1;\r
- }\r
- if ((abs(count - j)) > worst) {\r
- worst = abs(count - j);\r
- worstPos = i;\r
- }\r
- }\r
- state = 0;\r
- count=0;\r
- }\r
- }\r
- PrintToScrollback("Recovered %d raw bits", rawbit);\r
- PrintToScrollback("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos);\r
-\r
- // Finding the start of a UID\r
- int uidlen, long_wait;\r
- if(strcmp(str, "224") == 0) {\r
- uidlen=224;\r
- long_wait=30;\r
- } else {\r
- uidlen=64;\r
- long_wait=29;\r
- }\r
- int start;\r
- int first = 0;\r
- for(start = 0; start <= rawbit - uidlen; start++) {\r
- first = rawbits[start];\r
- for(i = start; i < start + long_wait; i++) {\r
- if(rawbits[i] != first) {\r
- break;\r
- }\r
- }\r
- if(i == (start + long_wait)) {\r
- break;\r
- }\r
- }\r
- if(start == rawbit - uidlen + 1) {\r
- PrintToScrollback("nothing to wait for");\r
- return;\r
- }\r
-\r
- // Inverting signal if needed\r
- if(first == 1) {\r
- for(i = start; i < rawbit; i++) {\r
- rawbits[i] = !rawbits[i];\r
- }\r
- }\r
-\r
- // Dumping UID\r
- BYTE bits[224];\r
- char showbits[225];\r
- showbits[uidlen]='\0';\r
- int bit;\r
- i = start;\r
- int times = 0;\r
- if(uidlen > rawbit) {\r
- PrintToScrollback("Warning: not enough raw bits to get a full UID");\r
- for(bit = 0; bit < rawbit; bit++) {\r
- bits[bit] = rawbits[i++];\r
- // As we cannot know the parity, let's use "." and "/"\r
- showbits[bit] = '.' + bits[bit];\r
- }\r
- showbits[bit+1]='\0';\r
- PrintToScrollback("Partial UID=%s", showbits);\r
- return;\r
- } else {\r
- for(bit = 0; bit < uidlen; bit++) {\r
- bits[bit] = rawbits[i++];\r
- showbits[bit] = '0' + bits[bit];\r
- }\r
- times = 1;\r
- }\r
- PrintToScrollback("UID=%s", showbits);\r
-\r
- // Checking UID against next occurences\r
- for(; i + uidlen <= rawbit;) {\r
- int failed = 0;\r
- for(bit = 0; bit < uidlen; bit++) {\r
- if(bits[bit] != rawbits[i++]) {\r
- failed = 1;\r
- break;\r
- }\r
- }\r
- if (failed == 1) {\r
- break;\r
- }\r
- times += 1;\r
- }\r
- PrintToScrollback("Occurences: %d (expected %d)", times, (rawbit - start) / uidlen);\r
-\r
- // Remodulating for tag cloning\r
- GraphTraceLen = 32*uidlen;\r
- i = 0;\r
- int phase = 0;\r
- for(bit = 0; bit < uidlen; bit++) {\r
- if(bits[bit] == 0) {\r
- phase = 0;\r
- } else {\r
- phase = 1;\r
- }\r
- int j;\r
- for(j = 0; j < 32; j++) {\r
- GraphBuffer[i++] = phase;\r
- phase = !phase;\r
- }\r
- }\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdFlexdemod(char *str)\r
-{\r
- int i;\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- if(GraphBuffer[i] < 0) {\r
- GraphBuffer[i] = -1;\r
- } else {\r
- GraphBuffer[i] = 1;\r
- }\r
- }\r
-\r
-#define LONG_WAIT 100\r
- int start;\r
- for(start = 0; start < GraphTraceLen - LONG_WAIT; start++) {\r
- int first = GraphBuffer[start];\r
- for(i = start; i < start + LONG_WAIT; i++) {\r
- if(GraphBuffer[i] != first) {\r
- break;\r
- }\r
- }\r
- if(i == (start + LONG_WAIT)) {\r
- break;\r
- }\r
- }\r
- if(start == GraphTraceLen - LONG_WAIT) {\r
- PrintToScrollback("nothing to wait for");\r
- return;\r
- }\r
-\r
- GraphBuffer[start] = 2;\r
- GraphBuffer[start+1] = -2;\r
-\r
- BYTE bits[64];\r
-\r
- int bit;\r
- i = start;\r
- for(bit = 0; bit < 64; bit++) {\r
- int j;\r
- int sum = 0;\r
- for(j = 0; j < 16; j++) {\r
- sum += GraphBuffer[i++];\r
- }\r
- if(sum > 0) {\r
- bits[bit] = 1;\r
- } else {\r
- bits[bit] = 0;\r
- }\r
- PrintToScrollback("bit %d sum %d", bit, sum);\r
- }\r
-\r
- for(bit = 0; bit < 64; bit++) {\r
- int j;\r
- int sum = 0;\r
- for(j = 0; j < 16; j++) {\r
- sum += GraphBuffer[i++];\r
- }\r
- if(sum > 0 && bits[bit] != 1) {\r
- PrintToScrollback("oops1 at %d", bit);\r
- }\r
- if(sum < 0 && bits[bit] != 0) {\r
- PrintToScrollback("oops2 at %d", bit);\r
- }\r
- }\r
-\r
- GraphTraceLen = 32*64;\r
- i = 0;\r
- int phase = 0;\r
- for(bit = 0; bit < 64; bit++) {\r
- if(bits[bit] == 0) {\r
- phase = 0;\r
- } else {\r
- phase = 1;\r
- }\r
- int j;\r
- for(j = 0; j < 32; j++) {\r
- GraphBuffer[i++] = phase;\r
- phase = !phase;\r
- }\r
- }\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-/*\r
- * Generic command to demodulate ASK.\r
- *\r
- * Argument is convention: positive or negative (High mod means zero\r
- * or high mod means one)\r
- *\r
- * Updates the Graph trace with 0/1 values\r
- *\r
- * Arguments:\r
- * c : 0 or 1\r
- */\r
-\r
-static void Cmdaskdemod(char *str) {\r
- int i;\r
- int c, high = 0, low = 0;\r
-\r
- // TODO: complain if we do not give 2 arguments here !\r
- // (AL - this doesn't make sense! we're only using one argument!!!)\r
- sscanf(str, "%i", &c);\r
-\r
- /* Detect high and lows and clock */\r
- // (AL - clock???)\r
- for (i = 0; i < GraphTraceLen; i++)\r
- {\r
- if (GraphBuffer[i] > high)\r
- high = GraphBuffer[i];\r
- else if (GraphBuffer[i] < low)\r
- low = GraphBuffer[i];\r
- }\r
- if(c != 0 && c != 1) {\r
- PrintToScrollback("Invalid argument: %s",str);\r
- return;\r
- }\r
-\r
- if (GraphBuffer[0] > 0) {\r
- GraphBuffer[0] = 1-c;\r
- } else {\r
- GraphBuffer[0] = c;\r
- }\r
- for(i=1;i<GraphTraceLen;i++) {\r
- /* Transitions are detected at each peak\r
- * Transitions are either:\r
- * - we're low: transition if we hit a high\r
- * - we're high: transition if we hit a low\r
- * (we need to do it this way because some tags keep high or\r
- * low for long periods, others just reach the peak and go\r
- * down)\r
- */\r
- if ((GraphBuffer[i]==high) && (GraphBuffer[i-1] == c)) {\r
- GraphBuffer[i]=1-c;\r
- } else if ((GraphBuffer[i]==low) && (GraphBuffer[i-1] == (1-c))){\r
- GraphBuffer[i] = c;\r
- } else {\r
- /* No transition */\r
- GraphBuffer[i] = GraphBuffer[i-1];\r
- }\r
- }\r
- RepaintGraphWindow();\r
-}\r
-\r
-/* Print our clock rate */\r
-static void Cmddetectclockrate(char *str)\r
-{\r
- int clock = detectclock(0);\r
- PrintToScrollback("Auto-detected clock rate: %d", clock);\r
-}\r
-\r
-/*\r
- * Detect clock rate\r
- */\r
-int detectclock(int peak)\r
-{\r
- int i;\r
- int clock = 0xFFFF;\r
- int lastpeak = 0;\r
-\r
- /* Detect peak if we don't have one */\r
- if (!peak)\r
- for (i = 0; i < GraphTraceLen; i++)\r
- if (GraphBuffer[i] > peak)\r
- peak = GraphBuffer[i];\r
-\r
- for (i = 1; i < GraphTraceLen; i++)\r
- {\r
- /* If this is the beginning of a peak */\r
- if (GraphBuffer[i-1] != GraphBuffer[i] && GraphBuffer[i] == peak)\r
- {\r
- /* Find lowest difference between peaks */\r
- if (lastpeak && i - lastpeak < clock)\r
- {\r
- clock = i - lastpeak;\r
- }\r
- lastpeak = i;\r
- }\r
- }\r
-\r
- return clock;\r
-}\r
-\r
-/* Get or auto-detect clock rate */\r
-int GetClock(char *str, int peak)\r
-{\r
- int clock;\r
-\r
- sscanf(str, "%i", &clock);\r
- if (!strcmp(str, ""))\r
- clock = 0;\r
-\r
- /* Auto-detect clock */\r
- if (!clock)\r
- {\r
- clock = detectclock(peak);\r
-\r
- /* Only print this message if we're not looping something */\r
- if (!go)\r
- PrintToScrollback("Auto-detected clock rate: %d", clock);\r
- }\r
-\r
- return clock;\r
-}\r
-\r
-/*\r
- * Convert to a bitstream\r
- */\r
-static void Cmdbitstream(char *str) {\r
- int i, j;\r
- int bit;\r
- int gtl;\r
- int clock;\r
- int low = 0;\r
- int high = 0;\r
- int hithigh, hitlow, first;\r
-\r
- /* Detect high and lows and clock */\r
- for (i = 0; i < GraphTraceLen; i++)\r
- {\r
- if (GraphBuffer[i] > high)\r
- high = GraphBuffer[i];\r
- else if (GraphBuffer[i] < low)\r
- low = GraphBuffer[i];\r
- }\r
-\r
- /* Get our clock */\r
- clock = GetClock(str, high);\r
-\r
- gtl = CmdClearGraph(0);\r
-\r
- bit = 0;\r
- for (i = 0; i < (int)(gtl / clock); i++)\r
- {\r
- hithigh = 0;\r
- hitlow = 0;\r
- first = 1;\r
-\r
- /* Find out if we hit both high and low peaks */\r
- for (j = 0; j < clock; j++)\r
- {\r
- if (GraphBuffer[(i * clock) + j] == high)\r
- hithigh = 1;\r
- else if (GraphBuffer[(i * clock) + j] == low)\r
- hitlow = 1;\r
-\r
- /* it doesn't count if it's the first part of our read\r
- because it's really just trailing from the last sequence */\r
- if (first && (hithigh || hitlow))\r
- hithigh = hitlow = 0;\r
- else\r
- first = 0;\r
-\r
- if (hithigh && hitlow)\r
- break;\r
- }\r
-\r
- /* If we didn't hit both high and low peaks, we had a bit transition */\r
- if (!hithigh || !hitlow)\r
- bit ^= 1;\r
-\r
- CmdAppendGraph(0, clock, bit);\r
-// for (j = 0; j < (int)(clock/2); j++)\r
-// GraphBuffer[(i * clock) + j] = bit ^ 1;\r
-// for (j = (int)(clock/2); j < clock; j++)\r
-// GraphBuffer[(i * clock) + j] = bit;\r
- }\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-/* Modulate our data into manchester */\r
-static void Cmdmanchestermod(char *str)\r
-{\r
- int i, j;\r
- int clock;\r
- int bit, lastbit, wave;\r
-\r
- /* Get our clock */\r
- clock = GetClock(str, 0);\r
-\r
- wave = 0;\r
- lastbit = 1;\r
- for (i = 0; i < (int)(GraphTraceLen / clock); i++)\r
- {\r
- bit = GraphBuffer[i * clock] ^ 1;\r
-\r
- for (j = 0; j < (int)(clock/2); j++)\r
- GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;\r
- for (j = (int)(clock/2); j < clock; j++)\r
- GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;\r
-\r
- /* Keep track of how we start our wave and if we changed or not this time */\r
- wave ^= bit ^ lastbit;\r
- lastbit = bit;\r
- }\r
-\r
- RepaintGraphWindow();\r
-}\r
-\r
-/*\r
- * Manchester demodulate a bitstream. The bitstream needs to be already in\r
- * the GraphBuffer as 0 and 1 values\r
- *\r
- * Give the clock rate as argument in order to help the sync - the algorithm\r
- * resyncs at each pulse anyway.\r
- *\r
- * Not optimized by any means, this is the 1st time I'm writing this type of\r
- * routine, feel free to improve...\r
- *\r
- * 1st argument: clock rate (as number of samples per clock rate)\r
- * Typical values can be 64, 32, 128...\r
- */\r
-static void Cmdmanchesterdemod(char *str) {\r
- int i, j, invert= 0;\r
- int bit;\r
- int clock;\r
- int lastval;\r
- int low = 0;\r
- int high = 0;\r
- int hithigh, hitlow, first;\r
- int lc = 0;\r
- int bitidx = 0;\r
- int bit2idx = 0;\r
- int warnings = 0;\r
-\r
- /* check if we're inverting output */\r
- if(*str == 'i')\r
- {\r
- PrintToScrollback("Inverting output");\r
- invert= 1;\r
- do\r
- ++str;\r
- while(*str == ' '); // in case a 2nd argument was given\r
- }\r
-\r
- /* Holds the decoded bitstream: each clock period contains 2 bits */\r
- /* later simplified to 1 bit after manchester decoding. */\r
- /* Add 10 bits to allow for noisy / uncertain traces without aborting */\r
- /* int BitStream[GraphTraceLen*2/clock+10]; */\r
-\r
- /* But it does not work if compiling on WIndows: therefore we just allocate a */\r
- /* large array */\r
- int BitStream[MAX_GRAPH_TRACE_LEN];\r
-\r
- /* Detect high and lows */\r
- for (i = 0; i < GraphTraceLen; i++)\r
- {\r
- if (GraphBuffer[i] > high)\r
- high = GraphBuffer[i];\r
- else if (GraphBuffer[i] < low)\r
- low = GraphBuffer[i];\r
- }\r
-\r
- /* Get our clock */\r
- clock = GetClock(str, high);\r
-\r
- int tolerance = clock/4;\r
-\r
- /* Detect first transition */\r
- /* Lo-Hi (arbitrary) */\r
- /* skip to the first high */\r
- for (i= 0; i < GraphTraceLen; i++)\r
- if(GraphBuffer[i] == high)\r
- break;\r
- /* now look for the first low */\r
- for (; i < GraphTraceLen; i++)\r
- {\r
- if (GraphBuffer[i] == low)\r
- {\r
- lastval = i;\r
- break;\r
- }\r
- }\r
-\r
- /* If we're not working with 1/0s, demod based off clock */\r
- if (high != 1)\r
- {\r
- bit = 0; /* We assume the 1st bit is zero, it may not be\r
- * the case: this routine (I think) has an init problem.\r
- * Ed.\r
- */\r
- for (; i < (int)(GraphTraceLen / clock); i++)\r
- {\r
- hithigh = 0;\r
- hitlow = 0;\r
- first = 1;\r
-\r
- /* Find out if we hit both high and low peaks */\r
- for (j = 0; j < clock; j++)\r
- {\r
- if (GraphBuffer[(i * clock) + j] == high)\r
- hithigh = 1;\r
- else if (GraphBuffer[(i * clock) + j] == low)\r
- hitlow = 1;\r
-\r
- /* it doesn't count if it's the first part of our read\r
- because it's really just trailing from the last sequence */\r
- if (first && (hithigh || hitlow))\r
- hithigh = hitlow = 0;\r
- else\r
- first = 0;\r
-\r
- if (hithigh && hitlow)\r
- break;\r
- }\r
-\r
- /* If we didn't hit both high and low peaks, we had a bit transition */\r
- if (!hithigh || !hitlow)\r
- bit ^= 1;\r
-\r
- BitStream[bit2idx++] = bit ^ invert;\r
- }\r
- }\r
-\r
- /* standard 1/0 bitstream */\r
- else\r
- {\r
-\r
- /* Then detect duration between 2 successive transitions */\r
- for (bitidx = 1; i < GraphTraceLen; i++)\r
- {\r
- if (GraphBuffer[i-1] != GraphBuffer[i])\r
- {\r
- lc = i-lastval;\r
- lastval = i;\r
-\r
- // Error check: if bitidx becomes too large, we do not\r
- // have a Manchester encoded bitstream or the clock is really\r
- // wrong!\r
- if (bitidx > (GraphTraceLen*2/clock+8) ) {\r
- PrintToScrollback("Error: the clock you gave is probably wrong, aborting.");\r
- return;\r
- }\r
- // Then switch depending on lc length:\r
- // Tolerance is 1/4 of clock rate (arbitrary)\r
- if (abs(lc-clock/2) < tolerance) {\r
- // Short pulse : either "1" or "0"\r
- BitStream[bitidx++]=GraphBuffer[i-1];\r
- } else if (abs(lc-clock) < tolerance) {\r
- // Long pulse: either "11" or "00"\r
- BitStream[bitidx++]=GraphBuffer[i-1];\r
- BitStream[bitidx++]=GraphBuffer[i-1];\r
- } else {\r
- // Error\r
- warnings++;\r
- PrintToScrollback("Warning: Manchester decode error for pulse width detection.");\r
- PrintToScrollback("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");\r
-\r
- if (warnings > 100)\r
- {\r
- PrintToScrollback("Error: too many detection errors, aborting.");\r
- return;\r
- }\r
- }\r
- }\r
- }\r
-\r
- // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream\r
- // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful\r
- // to stop output at the final bitidx2 value, not bitidx\r
- for (i = 0; i < bitidx; i += 2) {\r
- if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {\r
- BitStream[bit2idx++] = 1 ^ invert;\r
- } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {\r
- BitStream[bit2idx++] = 0 ^ invert;\r
- } else {\r
- // We cannot end up in this state, this means we are unsynchronized,\r
- // move up 1 bit:\r
- i++;\r
- warnings++;\r
- PrintToScrollback("Unsynchronized, resync...");\r
- PrintToScrollback("(too many of those messages mean the stream is not Manchester encoded)");\r
-\r
- if (warnings > 100)\r
- {\r
- PrintToScrollback("Error: too many decode errors, aborting.");\r
- return;\r
- }\r
- }\r
- }\r
- }\r
-\r
- PrintToScrollback("Manchester decoded bitstream");\r
- // Now output the bitstream to the scrollback by line of 16 bits\r
- for (i = 0; i < (bit2idx-16); i+=16) {\r
- PrintToScrollback("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",\r
- BitStream[i],\r
- BitStream[i+1],\r
- BitStream[i+2],\r
- BitStream[i+3],\r
- BitStream[i+4],\r
- BitStream[i+5],\r
- BitStream[i+6],\r
- BitStream[i+7],\r
- BitStream[i+8],\r
- BitStream[i+9],\r
- BitStream[i+10],\r
- BitStream[i+11],\r
- BitStream[i+12],\r
- BitStream[i+13],\r
- BitStream[i+14],\r
- BitStream[i+15]);\r
- }\r
-}\r
-\r
-/*\r
- * Usage ???\r
- */\r
-static void CmdHiddemod(char *str)\r
-{\r
- if(GraphTraceLen < 4800) {\r
- PrintToScrollback("too short; need at least 4800 samples");\r
- return;\r
- }\r
-\r
- GraphTraceLen = 4800;\r
- int i;\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- if(GraphBuffer[i] < 0) {\r
- GraphBuffer[i] = 0;\r
- } else {\r
- GraphBuffer[i] = 1;\r
- }\r
- }\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdPlot(char *str)\r
-{\r
- ShowGraphWindow();\r
-}\r
-\r
-static void CmdGrid(char *str)\r
-{\r
- sscanf(str, "%i %i", &PlotGridX, &PlotGridY);\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdHide(char *str)\r
-{\r
- HideGraphWindow();\r
-}\r
-\r
-static void CmdScale(char *str)\r
-{\r
- CursorScaleFactor = atoi(str);\r
- if(CursorScaleFactor == 0) {\r
- PrintToScrollback("bad, can't have zero scale");\r
- CursorScaleFactor = 1;\r
- }\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdSave(char *str)\r
-{\r
- FILE *f = fopen(str, "w");\r
- if(!f) {\r
- PrintToScrollback("couldn't open '%s'", str);\r
- return;\r
- }\r
- int i;\r
- for(i = 0; i < GraphTraceLen; i++) {\r
- fprintf(f, "%d\n", GraphBuffer[i]);\r
- }\r
- fclose(f);\r
- PrintToScrollback("saved to '%s'", str);\r
-}\r
-\r
-static void CmdLoad(char *str)\r
-{\r
- FILE *f = fopen(str, "r");\r
- if(!f) {\r
- PrintToScrollback("couldn't open '%s'", str);\r
- return;\r
- }\r
-\r
- GraphTraceLen = 0;\r
- char line[80];\r
- while(fgets(line, sizeof(line), f)) {\r
- GraphBuffer[GraphTraceLen] = atoi(line);\r
- GraphTraceLen++;\r
- }\r
- fclose(f);\r
- PrintToScrollback("loaded %d samples", GraphTraceLen);\r
- RepaintGraphWindow();\r
-}\r
-\r
-static void CmdHIDsimTAG(char *str)\r
-{\r
- unsigned int hi=0, lo=0;\r
- int n=0, i=0;\r
- UsbCommand c;\r
-\r
- while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
- hi=(hi<<4)|(lo>>28);\r
- lo=(lo<<4)|(n&0xf);\r
- }\r
-\r
- PrintToScrollback("Emulating tag with ID %x%16x", hi, lo);\r
-\r
- c.cmd = CMD_HID_SIM_TAG;\r
- c.ext1 = hi;\r
- c.ext2 = lo;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdReadmem(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_READ_MEM;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdVersion(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_VERSION;\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdLcdReset(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_LCD_RESET;\r
- c.ext1 = atoi(str);\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-static void CmdLcd(char *str)\r
-{\r
- int i, j;\r
- UsbCommand c;\r
- c.cmd = CMD_LCD;\r
- sscanf(str, "%x %d", &i, &j);\r
- while (j--) {\r
- c.ext1 = i&0x1ff;\r
- SendCommand(&c, FALSE);\r
- }\r
-}\r
-\r
-/*\r
- * Sets the divisor for LF frequency clock: lets the user choose any LF frequency below\r
- * 600kHz.\r
- */\r
-static void CmdSetDivisor(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SET_LF_DIVISOR;\r
- c.ext1 = atoi(str);\r
- if (( c.ext1<0) || (c.ext1>255)) {\r
- PrintToScrollback("divisor must be between 19 and 255");\r
- } else {\r
- SendCommand(&c, FALSE);\r
- PrintToScrollback("Divisor set, expected freq=%dHz", 12000000/(c.ext1+1));\r
- }\r
-}\r
-\r
-static void CmdSetMux(char *str)\r
-{\r
- UsbCommand c;\r
- c.cmd = CMD_SET_ADC_MUX;\r
- if(strcmp(str, "lopkd") == 0) {\r
- c.ext1 = 0;\r
- } else if(strcmp(str, "loraw") == 0) {\r
- c.ext1 = 1;\r
- } else if(strcmp(str, "hipkd") == 0) {\r
- c.ext1 = 2;\r
- } else if(strcmp(str, "hiraw") == 0) {\r
- c.ext1 = 3;\r
- }\r
- SendCommand(&c, FALSE);\r
-}\r
-\r
-typedef void HandlerFunction(char *cmdline);\r
-\r
-/* in alphabetic order */\r
-static struct {\r
- char *name;\r
- HandlerFunction *handler;\r
- int offline; // 1 if the command can be used when in offline mode\r
- char *docString;\r
-} CommandTable[] = {\r
- {"amp", CmdAmp, 1, "Amplify peaks"},\r
- {"askdemod", Cmdaskdemod, 1, "<0|1> -- Attempt to demodulate simple ASK tags"},\r
- {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},\r
- {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},\r
- {"bitstream", Cmdbitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},\r
- {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},\r
- {"dec", CmdDec, 1, "Decimate samples"},\r
- {"detectclock", Cmddetectclockrate, 1, "Detect clock rate"},\r
- {"detectreader", CmdDetectReader, 0, "['l'|'h'] -- Detect external reader field (option 'l' or 'h' to limit to LF or HF)"},\r
- {"em410xsim", CmdEM410xsim, 1, "<UID> -- Simulate EM410x tag"},\r
- {"em410xread", CmdEM410xread, 1, "[clock rate] -- Extract ID from EM410x tag"},\r
- {"em410xwatch", CmdEM410xwatch, 0, "Watches for EM410x tags"},\r
- {"em4x50read", CmdEM4x50read, 1, "Extract data from EM4x50 tag"},\r
- {"exit", CmdQuit, 1, "Exit program"},\r
- {"flexdemod", CmdFlexdemod, 1, "Demodulate samples for FlexPass"},\r
- {"fpgaoff", CmdFPGAOff, 0, "Set FPGA off"},\r
- {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},\r
- {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},\r
- {"hexsamples", CmdHexsamples, 0, "<blocks> -- Dump big buffer as hex bytes"},\r
- {"hi14alist", CmdHi14alist, 0, "List ISO 14443a history"},\r
- {"hi14areader", CmdHi14areader, 0, "Act like an ISO14443 Type A reader"},\r
- {"hi14asim", CmdHi14asim, 0, "<UID> -- Fake ISO 14443a tag"},\r
- {"hi14asnoop", CmdHi14asnoop, 0, "Eavesdrop ISO 14443 Type A"},\r
- {"hi14bdemod", CmdHi14bdemod, 1, "Demodulate ISO14443 Type B from tag"},\r
- {"hi14list", CmdHi14list, 0, "List ISO 14443 history"},\r
- {"hi14read", CmdHi14read, 0, "Read HF tag (ISO 14443)"},\r
- {"hi14sim", CmdHi14sim, 0, "Fake ISO 14443 tag"},\r
- {"hi14snoop", CmdHi14snoop, 0, "Eavesdrop ISO 14443"},\r
- {"hi15demod", CmdHi15demod, 1, "Demodulate ISO15693 from tag"},\r
- {"hi15read", CmdHi15read, 0, "Read HF tag (ISO 15693)"},\r
- {"hi15reader", CmdHi15reader, 0, "Act like an ISO15693 reader"},\r
- {"hi15sim", CmdHi15tag, 0, "Fake an ISO15693 tag"},\r
- {"hiddemod", CmdHiddemod, 1, "Demodulate HID Prox Card II (not optimal)"},\r
- {"hide", CmdHide, 1, "Hide graph window"},\r
- {"hidfskdemod", CmdHIDdemodFSK, 0, "Realtime HID FSK demodulator"},\r
- {"hidsimtag", CmdHIDsimTAG, 0, "<ID> -- HID tag simulator"},\r
- {"higet", CmdHi14read_sim, 0, "<samples> -- Get samples HF, 'analog'"},\r
- {"hisamples", CmdHisamples, 0, "Get raw samples for HF tag"},\r
- {"hisampless", CmdHisampless, 0, "<samples> -- Get signed raw samples, HF tag"},\r
- {"hisamplest", CmdHi14readt, 0, "Get samples HF, for testing"},\r
- {"hisimlisten", CmdHisimlisten, 0, "Get HF samples as fake tag"},\r
- {"hpf", CmdHpf, 1, "Remove DC offset from trace"},\r
- {"indalademod", CmdIndalademod, 0, "['224'] -- Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"},\r
- {"lcd", CmdLcd, 0, "<HEX command> <count> -- Send command/data to LCD"},\r
- {"lcdreset", CmdLcdReset, 0, "Hardware reset LCD"},\r
- {"legicrfsim", CmdLegicRfSim, 0, "Start the LEGIC RF tag simulator"},\r
- {"legicrfread", CmdLegicRfRead, 0, "Start the LEGIC RF reader"},\r
- {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},\r
- {"locomread", CmdLoCommandRead, 0, "<off period> <'0' period> <'1' period> <command> ['h'] -- Modulate LF reader field to send command before read (all periods in microseconds) (option 'h' for 134)"},\r
- {"loread", CmdLoread, 0, "['h'] -- Read 125/134 kHz LF ID-only tag (option 'h' for 134)"},\r
- {"losamples", CmdLosamples, 0, "[128 - 16000] -- Get raw samples for LF tag"},\r
- {"losim", CmdLosim, 0, "Simulate LF tag"},\r
- {"losimbidir", CmdLosimBidir, 0, "Simulate LF tag (with bidirectional data transmission between reader and tag)"},\r
- {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},\r
- {"mandemod", Cmdmanchesterdemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},\r
- {"manmod", Cmdmanchestermod, 1, "[clock rate] -- Manchester modulate a binary stream"},\r
- {"norm", CmdNorm, 1, "Normalize max/min to +/-500"},\r
- {"plot", CmdPlot, 1, "Show graph window"},\r
- {"quit", CmdQuit, 1, "Quit program"},\r
- {"readmem", CmdReadmem, 0, "[address] -- Read memory at decimal address from flash"},\r
- {"reset", CmdReset, 0, "Reset the Proxmark3"},\r
- {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},\r
- {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},\r
- {"setlfdivisor", CmdSetDivisor, 0, "<19 - 255> -- Drive LF antenna at 12Mhz/(divisor+1)"},\r
- {"setmux", CmdSetMux, 0, "<loraw|hiraw|lopkd|hipkd> -- Set the ADC mux to a specific value"},\r
- {"sri512read", CmdSri512read, 0, "<int> -- Read contents of a SRI512 tag"},\r
- {"srix4kread", CmdSrix4kread, 0, "<int> -- Read contents of a SRIX4K tag"},
- {"tidemod", CmdTIDemod, 1, "Demodulate raw bits for TI-type LF tag"},\r
- {"tiread", CmdTIRead, 0, "Read and decode a TI 134 kHz tag"},\r
- {"tiwrite", CmdTIWrite, 0, "Write new data to a r/w TI 134 kHz tag"},\r
- {"threshold", CmdThreshold, 1, "Maximize/minimize every value in the graph window depending on threshold"},\r
- {"tune", CmdTune, 0, "Measure antenna tuning"},\r
- {"vchdemod", CmdVchdemod, 0, "['clone'] -- Demodulate samples for VeriChip"},\r
- {"version", CmdVersion, 0, "Show version inforation about the connected Proxmark"},\r
- {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},\r
-};\r
-\r
-static struct {\r
- char *name;\r
- char *args;\r
- char *argshelp;\r
- char *description;\r
- } CommandExtendedHelp[]= {\r
- {"detectreader","'l'|'h'","'l' specifies LF antenna scan only, 'h' specifies HF antenna scan only.","Monitor antenna for changes in voltage. Output is in three fields: CHANGED, CURRENT, PERIOD,\nwhere CHANGED is the value just changed from, CURRENT is the current value and PERIOD is the\nnumber of program loops since the last change.\n\nThe RED LED indicates LF field detected, and the GREEN LED indicates HF field detected."},\r
- {"tune","","","Drive LF antenna at all divisor range values (19 - 255) and store the results in the output\nbuffer. Issuing 'losamples' and then 'plot' commands will display the resulting peak. 12MHz\ndivided by the peak's position plus one gives the antenna's resonant frequency. For convenience,\nthis value is also printed out by the command."},\r
- };\r
-\r
-//-----------------------------------------------------------------------------\r
-// Entry point into our code: called whenever the user types a command and\r
-// then presses Enter, which the full command line that they typed.\r
-//-----------------------------------------------------------------------------\r
-void CommandReceived(char *cmd)\r
-{\r
- int i;\r
- char line[256];\r
-\r
- PrintToScrollback("> %s", cmd);\r
-\r
- if(strcmp(cmd, "help") == 0 || strncmp(cmd,"help ",strlen("help ")) == 0) {\r
- // check if we're doing extended help\r
- if(strlen(cmd) > strlen("help ")) {\r
- cmd += strlen("help ");\r
- for(i = 0; i < sizeof(CommandExtendedHelp) / sizeof(CommandExtendedHelp[0]); i++) {\r
- if(strcmp(CommandExtendedHelp[i].name,cmd) == 0) {\r
- PrintToScrollback("\nExtended help for '%s':\n", cmd);\r
- PrintToScrollback("Args: %s\t- %s\n",CommandExtendedHelp[i].args,CommandExtendedHelp[i].argshelp);\r
- PrintToScrollback(CommandExtendedHelp[i].description);\r
- PrintToScrollback("");\r
- return;\r
- }\r
- }\r
- PrintToScrollback("No extended help available for '%s'", cmd);\r
- return;\r
- }\r
- if (offline) PrintToScrollback("Operating in OFFLINE mode (no device connected)");\r
- PrintToScrollback("\r\nAvailable commands:");\r
- for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
- if (offline && (CommandTable[i].offline==0)) continue;\r
- memset(line, ' ', sizeof(line));\r
- strcpy(line+2, CommandTable[i].name);\r
- line[strlen(line)] = ' ';\r
- sprintf(line+15, " -- %s", CommandTable[i].docString);\r
- PrintToScrollback("%s", line);\r
- }\r
- PrintToScrollback("");\r
- PrintToScrollback("'help <command>' for extended help on that command\n");\r
- return;\r
- }\r
-\r
- for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
- char *name = CommandTable[i].name;\r
- if(memcmp(cmd, name, strlen(name))==0 &&\r
- (cmd[strlen(name)] == ' ' || cmd[strlen(name)] == '\0'))\r
- {\r
- cmd += strlen(name);\r
- while(*cmd == ' ') {\r
- cmd++;\r
- }\r
- if (offline && (CommandTable[i].offline==0)) {\r
- PrintToScrollback("Offline mode, cannot use this command.");\r
- return;\r
- }\r
- (CommandTable[i].handler)(cmd);\r
- return;\r
- }\r
- }\r
- PrintToScrollback(">> bad command '%s'", cmd);\r
-}\r
-\r
-//-----------------------------------------------------------------------------\r
-// Entry point into our code: called whenever we received a packet over USB\r
-// that we weren't necessarily expecting, for example a debug print.\r
-//-----------------------------------------------------------------------------\r
-void UsbCommandReceived(UsbCommand *c)\r
-{\r
- switch(c->cmd) {\r
- case CMD_DEBUG_PRINT_STRING: {\r
- char s[100];\r
- if(c->ext1 > 70 || c->ext1 < 0) {\r
- c->ext1 = 0;\r
- }\r
- memcpy(s, c->d.asBytes, c->ext1);\r
- s[c->ext1] = '\0';\r
- PrintToScrollback("#db# %s", s);\r
- break;\r
- }\r
-\r
- case CMD_DEBUG_PRINT_INTEGERS:\r
- PrintToScrollback("#db# %08x, %08x, %08x\r\n", c->ext1, c->ext2, c->ext3);\r
- break;\r
-\r
- case CMD_MEASURED_ANTENNA_TUNING: {\r
- int peakv, peakf;\r
- int vLf125, vLf134, vHf;\r
- vLf125 = c->ext1 & 0xffff;\r
- vLf134 = c->ext1 >> 16;\r
- vHf = c->ext2 & 0xffff;;\r
- peakf = c->ext3 & 0xffff;\r
- peakv = c->ext3 >> 16;\r
- PrintToScrollback("");\r
- PrintToScrollback("");\r
- PrintToScrollback("# LF antenna: %5.2f V @ 125.00 kHz", vLf125/1000.0);\r
- PrintToScrollback("# LF antenna: %5.2f V @ 134.00 kHz", vLf134/1000.0);\r
- PrintToScrollback("# LF optimal: %5.2f V @%9.2f kHz", peakv/1000.0, 12000.0/(peakf+1));\r
- PrintToScrollback("# HF antenna: %5.2f V @ 13.56 MHz", vHf/1000.0);\r
- if (peakv<2000)\r
- PrintToScrollback("# Your LF antenna is unusable.");\r
- else if (peakv<10000)\r
- PrintToScrollback("# Your LF antenna is marginal.");\r
- if (vHf<2000)\r
- PrintToScrollback("# Your HF antenna is unusable.");\r
- else if (vHf<5000)\r
- PrintToScrollback("# Your HF antenna is marginal.");\r
- break;\r
- }\r
- default:\r
- PrintToScrollback("unrecognized command %08x\n", c->cmd);\r
- break;\r
- }\r
-}\r
+++ /dev/null
-//-----------------------------------------------------------------------------\r
-// Routines for the user interface when doing interactive things with prox\r
-// cards; this is basically a command line thing, in one window, and then\r
-// another window to do the graphs.\r
-// Jonathan Westhues, Sept 2005\r
-//-----------------------------------------------------------------------------\r
-#include <windows.h>\r
-#include <limits.h>\r
-#include <commctrl.h>\r
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <math.h>\r
-\r
-#include "prox.h"\r
-\r
-#define oops() do { \\r
- char line[100]; \\r
- sprintf(line, "Internal error at line %d file '%s'", __LINE__, \\r
- __FILE__); \\r
- MessageBox(NULL, line, "Error", MB_ICONERROR); \\r
- exit(-1); \\r
-} while(0)\r
-\r
-void dbp(char *str, ...)\r
-{\r
- va_list f;\r
- char buf[1024];\r
- va_start(f, str);\r
- vsprintf(buf, str, f);\r
- OutputDebugString(buf);\r
- OutputDebugString("\n");\r
-}\r
-\r
-int GraphBuffer[MAX_GRAPH_TRACE_LEN];\r
-int GraphTraceLen;\r
-int PlotGridX, PlotGridY;\r
-\r
-HPEN GreyPenLite, GreyPen, GreenPen, WhitePen, YellowPen;\r
-HBRUSH GreenBrush, YellowBrush;\r
-\r
-static int GraphStart = 0;\r
-static double GraphPixelsPerPoint = 1;\r
-\r
-static int CursorAPos;\r
-static int CursorBPos;\r
-double CursorScaleFactor = 1.0;\r
-static HPEN CursorAPen;\r
-static HPEN CursorBPen;\r
-\r
-static HWND CommandWindow;\r
-static HWND GraphWindow;\r
-static HWND ScrollbackEdit;\r
-static HWND CommandEdit;\r
-\r
-#define COMMAND_HISTORY_MAX 16\r
-static char CommandHistory[COMMAND_HISTORY_MAX][256];\r
-static int CommandHistoryPos = -1;\r
-static int CommandHistoryNext;\r
-\r
-static HFONT MyFixedFont;\r
-#define FixedFont(x) SendMessage((x), WM_SETFONT, (WPARAM)MyFixedFont, TRUE)\r
-\r
-void ExecCmd(char *cmd)\r
-{\r
-}\r
-\r
-int CommandFinished;\r
-int offset = 64;\r
-\r
-static void ResizeCommandWindow(void)\r
-{\r
- int w, h;\r
- RECT r;\r
- GetClientRect(CommandWindow, &r);\r
- w = r.right - r.left;\r
- h = r.bottom - r.top;\r
- MoveWindow(ScrollbackEdit, 10, 10, w - 20, h - 50, TRUE);\r
- MoveWindow(CommandEdit, 10, h - 29, w - 20, 22, TRUE);\r
-}\r
-\r
-void RepaintGraphWindow(void)\r
-{\r
- InvalidateRect(GraphWindow, NULL, TRUE);\r
-}\r
-\r
-static LRESULT CALLBACK\r
- CommandWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)\r
-{\r
- switch (msg) {\r
- case WM_DESTROY:\r
- case WM_QUIT:\r
- exit(0);\r
- return 0;\r
-\r
- case WM_SIZE:\r
- ResizeCommandWindow();\r
- return 0;\r
-\r
- case WM_SETFOCUS:\r
- SetFocus(CommandEdit);\r
- break;\r
-\r
- default:\r
- return DefWindowProc(hwnd, msg, wParam, lParam);\r
- }\r
-\r
- return 1;\r
-}\r
-\r
-static void PaintGraph(HDC hdc)\r
-{\r
- RECT r;\r
- HBRUSH brush;\r
- HPEN pen;\r
- char str[250];\r
- int yMin = INT_MAX;\r
- int yMax = INT_MIN;\r
- int yMean = 0;\r
- int startMax = 0;\r
- int absYMax = 1;\r
- int n = 0, i = 0;\r
-\r
- brush = GreenBrush;\r
- pen = GreenPen;\r
-\r
- GetClientRect(GraphWindow, &r);\r
- int zeroHeight = (r.top + r.bottom) >> 1;\r
-\r
- // plot X and Y grid lines\r
- if ((PlotGridX > 0) && ((PlotGridX * GraphPixelsPerPoint) > 1)) {\r
- for(i = offset; i < r.right; i += (int)(PlotGridX * GraphPixelsPerPoint)) {\r
- SelectObject(hdc, GreyPenLite);\r
- MoveToEx(hdc, r.left + i, r.top, NULL);\r
- LineTo(hdc, r.left + i, r.bottom);\r
- }\r
- }\r
-\r
- if ((PlotGridY > 0) && ((PlotGridY * GraphPixelsPerPoint) > 1)){\r
- for(i = 0; i < ((r.top + r.bottom)>>1); i += (int)(PlotGridY * GraphPixelsPerPoint)) {\r
- SelectObject(hdc, GreyPenLite);\r
- MoveToEx(hdc, r.left, zeroHeight + i, NULL);\r
- LineTo(hdc, r.right, zeroHeight + i);\r
- MoveToEx(hdc, r.left, zeroHeight - i, NULL);\r
- LineTo(hdc, r.right, zeroHeight - i);\r
- }\r
- }\r
-\r
- // print vertical separator white line on the left of the window\r
- SelectObject(hdc, WhitePen);\r
- MoveToEx(hdc, r.left + offset, r.top, NULL);\r
- LineTo(hdc, r.left + offset, r.bottom);\r
-\r
- // print horizontal grey zero axis line\r
- SelectObject(hdc, GreyPen);\r
- MoveToEx(hdc, r.left, zeroHeight, NULL);\r
- LineTo(hdc, r.right, zeroHeight);\r
-\r
- startMax = (GraphTraceLen - (int)((r.right - r.left - offset) / GraphPixelsPerPoint));\r
- // check boundaries\r
- if(startMax < 0) startMax = 0;\r
- if(GraphStart > startMax) GraphStart = startMax;\r
- if(GraphStart < 0) GraphStart = 0;\r
-\r
-\r
- SelectObject(hdc, pen);\r
-\r
- // go over the portion of the graph to be displayed and find the largest\r
- // absolute value which will be used to auto scale the graph when displayed\r
- for(i = GraphStart; ; i++) {\r
- if(i >= GraphTraceLen) {\r
- break;\r
- }\r
- if(fabs((double)GraphBuffer[i]) > absYMax) {\r
- absYMax = (int)fabs((double)GraphBuffer[i]);\r
- }\r
- int x = offset + (int)((i - GraphStart)*GraphPixelsPerPoint);\r
- if(x > r.right) {\r
- break;\r
- }\r
- }\r
-\r
- absYMax = (int)(absYMax*1.2 + 1);\r
- SelectObject(hdc, MyFixedFont);\r
- SetTextColor(hdc, RGB(255, 255, 255));\r
- SetBkColor(hdc, RGB(0, 0, 0));\r
-\r
- // number of points that will be plotted\r
- double span = (int)((r.right - r.left) / GraphPixelsPerPoint);\r
-\r
- // one label every offset pixels, let us say\r
- int labels = (r.right - r.left - offset) / offset;\r
- if(labels <= 0) labels = 1;\r
- // round to nearest power of 2\r
- int pointsPerLabel = (int)(log(span / labels)/log(2.0));\r
- if(pointsPerLabel <= 0) pointsPerLabel = 1;\r
- pointsPerLabel = (int)pow(2.0,pointsPerLabel);\r
-\r
- // go over the graph and plot samples and labels\r
- for(i = GraphStart; ; i++) {\r
- if(i >= GraphTraceLen) {\r
- break;\r
- }\r
- int x = offset + (int)((i - GraphStart)*GraphPixelsPerPoint);\r
- if(x > r.right + GraphPixelsPerPoint) {\r
- break;\r
- }\r
-\r
- int y = GraphBuffer[i];\r
- if(y < yMin) yMin = y;\r
- if(y > yMax) yMax = y;\r
- yMean += y;\r
- n++;\r
-\r
- y = (y * (r.top - r.bottom) / (2*absYMax)) + zeroHeight;\r
- if(i == GraphStart) {\r
- MoveToEx(hdc, x, y, NULL);\r
- } else {\r
- LineTo(hdc, x, y);\r
- }\r
-\r
- if(GraphPixelsPerPoint > 10) {\r
- RECT f;\r
- f.left = x - 3;\r
- f.top = y - 3;\r
- f.right = x + 3;\r
- f.bottom = y + 3;\r
- FillRect(hdc, &f, brush);\r
- }\r
-\r
- // plot labels\r
- if(((i - GraphStart) % pointsPerLabel == 0) && i != GraphStart) {\r
- SelectObject(hdc, WhitePen);\r
- MoveToEx(hdc, x, zeroHeight - 8, NULL);\r
- LineTo(hdc, x, zeroHeight + 8);\r
-\r
- sprintf(str, "+%d", i);\r
- SIZE size;\r
- GetTextExtentPoint32(hdc, str, strlen(str), &size);\r
- TextOut(hdc, x - size.cx, zeroHeight + 8, str, strlen(str));\r
-\r
- SelectObject(hdc, pen);\r
- MoveToEx(hdc, x, y, NULL);\r
- }\r
-\r
- // plot measurement cursors\r
- if(i == CursorAPos || i == CursorBPos) {\r
- if(i == CursorAPos) {\r
- SelectObject(hdc, CursorAPen);\r
- } else {\r
- SelectObject(hdc, CursorBPen);\r
- }\r
- MoveToEx(hdc, x, r.top, NULL);\r
- LineTo(hdc, x, r.bottom);\r
-\r
- SelectObject(hdc, pen);\r
- MoveToEx(hdc, x, y, NULL);\r
- }\r
- }\r
-\r
- if(n != 0) {\r
- yMean /= n;\r
- }\r
-\r
- // print misc information at bottom of graph window\r
- sprintf(str, "@%d max=%d min=%d mean=%d n=%d/%d dt=%d [%.3f] zoom=%.3f CursorA=%d [%d] CursorB=%d [%d]",\r
- GraphStart, yMax, yMin, yMean, n, GraphTraceLen,\r
- CursorBPos - CursorAPos, (CursorBPos - CursorAPos)/CursorScaleFactor, GraphPixelsPerPoint,\r
- CursorAPos, GraphBuffer[CursorAPos], CursorBPos, GraphBuffer[CursorBPos]);\r
- TextOut(hdc, 50, r.bottom - 20, str, strlen(str));\r
-}\r
-\r
-static LRESULT CALLBACK\r
- GraphWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)\r
-{\r
- switch (msg) {\r
- case WM_DESTROY:\r
- case WM_QUIT:\r
- GraphWindow = NULL;\r
- return DefWindowProc(hwnd, msg, wParam, lParam);\r
-\r
- case WM_SIZE:\r
- RepaintGraphWindow();\r
- return 0;\r
-\r
- case WM_PAINT: {\r
- PAINTSTRUCT ps;\r
- HDC hdc = BeginPaint(hwnd, &ps);\r
- if(GraphStart < 0) {\r
- GraphStart = 0;\r
- }\r
- // This draws the trace.\r
- PaintGraph(hdc);\r
- EndPaint(hwnd, &ps);\r
- break;\r
- }\r
- case WM_KEYDOWN:\r
- switch(wParam) {\r
- case VK_DOWN:\r
- if(GraphPixelsPerPoint <= 8) {\r
- GraphPixelsPerPoint *= 2;\r
- }\r
- break;\r
-\r
- case VK_UP:\r
- if(GraphPixelsPerPoint >= 0.01) {\r
- GraphPixelsPerPoint /= 2;\r
- }\r
- break;\r
-\r
- case VK_RIGHT:\r
- if(GraphPixelsPerPoint < 16) {\r
- GraphStart += (int)(16 / GraphPixelsPerPoint);\r
- } else {\r
- GraphStart++;\r
- }\r
- break;\r
-\r
- case VK_LEFT:\r
- if(GraphPixelsPerPoint < 16) {\r
- GraphStart -= (int)(16 / GraphPixelsPerPoint);\r
- } else {\r
- GraphStart--;\r
- }\r
- break;\r
-\r
- default:\r
- goto nopaint;\r
- }\r
- RepaintGraphWindow();\r
-nopaint:\r
- break;\r
-\r
- case WM_LBUTTONDOWN:\r
- case WM_RBUTTONDOWN: {\r
- int x = LOWORD(lParam);\r
- x -= offset;\r
- x = (int)(x / GraphPixelsPerPoint);\r
- x += GraphStart;\r
-\r
- if(msg == WM_LBUTTONDOWN) {\r
- CursorAPos = x;\r
- } else {\r
- CursorBPos = x;\r
- }\r
- RepaintGraphWindow();\r
- break;\r
- }\r
- default:\r
- return DefWindowProc(hwnd, msg, wParam, lParam);\r
- }\r
-\r
- return 1;\r
-}\r
-\r
-void PrintToScrollback(char *fmt, ...)\r
-{\r
- va_list f;\r
- char str[1024];\r
- strcpy(str, "\r\n");\r
- va_start(f, fmt);\r
- vsprintf(str+2, fmt, f);\r
-\r
- static char TextBuf[1024*32];\r
- SendMessage(ScrollbackEdit, WM_GETTEXT, (WPARAM)sizeof(TextBuf),\r
- (LPARAM)TextBuf);\r
-\r
- if(strlen(TextBuf) + strlen(str) + 1 <= sizeof(TextBuf)) {\r
- strcat(TextBuf, str);\r
- } else {\r
- lstrcpyn(TextBuf, str, sizeof(TextBuf));\r
- }\r
-\r
- SendMessage(ScrollbackEdit, WM_SETTEXT, 0, (LPARAM)TextBuf);\r
- SendMessage(ScrollbackEdit, EM_LINESCROLL, 0, (LPARAM)INT_MAX);\r
-}\r
-\r
-void ShowGraphWindow(void)\r
-{\r
- if(GraphWindow) return;\r
-\r
- GraphWindow = CreateWindowEx(0, "Graph", "graphed",\r
- WS_OVERLAPPED | WS_BORDER | WS_MINIMIZEBOX | WS_SYSMENU |\r
- WS_SIZEBOX | WS_VISIBLE, 200, 150, 600, 500, NULL, NULL, NULL,\r
- NULL);\r
- if(!GraphWindow) oops();\r
-}\r
-\r
-void HideGraphWindow(void)\r
-{\r
- if(GraphWindow) {\r
- DestroyWindow(GraphWindow);\r
- GraphWindow = NULL;\r
- }\r
-}\r
-\r
-static void SetCommandEditTo(char *str)\r
-{\r
- SendMessage(CommandEdit, WM_SETTEXT, 0, (LPARAM)str);\r
- SendMessage(CommandEdit, EM_SETSEL, strlen(str), strlen(str));\r
-}\r
-\r
-void ShowGui()\r
-{\r
- WNDCLASSEX wc;\r
- memset(&wc, 0, sizeof(wc));\r
- wc.cbSize = sizeof(wc);\r
-\r
- wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC;\r
- wc.lpfnWndProc = (WNDPROC)CommandWindowProc;\r
- wc.hInstance = NULL;\r
- wc.hbrBackground = (HBRUSH)(COLOR_BTNSHADOW);\r
- wc.lpszClassName = "Command";\r
- wc.lpszMenuName = NULL;\r
- wc.hCursor = LoadCursor(NULL, IDC_ARROW);\r
-\r
- if(!RegisterClassEx(&wc)) oops();\r
-\r
- wc.lpszClassName = "Graph";\r
- wc.lpfnWndProc = (WNDPROC)GraphWindowProc;\r
- wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);\r
-\r
- if(!RegisterClassEx(&wc)) oops();\r
-\r
- CommandWindow = CreateWindowEx(0, "Command", "prox",\r
- WS_OVERLAPPED | WS_BORDER | WS_MINIMIZEBOX | WS_SYSMENU |\r
- WS_SIZEBOX | WS_VISIBLE, 20, 20, 500, 400, NULL, NULL, NULL,\r
- NULL);\r
- if(!CommandWindow) oops();\r
-\r
- ScrollbackEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "edit", "",\r
- WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | ES_MULTILINE |\r
- ES_AUTOVSCROLL | WS_VSCROLL, 0, 0, 0, 0, CommandWindow, NULL,\r
- NULL, NULL);\r
-\r
- CommandEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "edit", "",\r
- WS_CHILD | WS_CLIPSIBLINGS | WS_TABSTOP | WS_VISIBLE |\r
- ES_AUTOHSCROLL, 0, 0, 0, 0, CommandWindow, NULL, NULL, NULL);\r
-\r
- MyFixedFont = CreateFont(14, 0, 0, 0, FW_REGULAR, FALSE, FALSE, FALSE,\r
- ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,\r
- FF_DONTCARE, "Lucida Console");\r
- if(!MyFixedFont)\r
- MyFixedFont = (HFONT)GetStockObject(SYSTEM_FONT);\r
-\r
- FixedFont(ScrollbackEdit);\r
- FixedFont(CommandEdit);\r
-\r
- ResizeCommandWindow();\r
- SetFocus(CommandEdit);\r
-\r
- PrintToScrollback(">> Started prox, built " __DATE__ " " __TIME__);\r
- PrintToScrollback(">> Connected to device");\r
-\r
- GreyPenLite = CreatePen(PS_SOLID, 1, RGB(50, 50, 50));\r
- GreyPen = CreatePen(PS_SOLID, 1, RGB(100, 100, 100));\r
- GreenPen = CreatePen(PS_SOLID, 1, RGB(100, 255, 100));\r
- YellowPen = CreatePen(PS_SOLID, 1, RGB(255, 255, 0));\r
- GreenBrush = CreateSolidBrush(RGB(100, 255, 100));\r
- YellowBrush = CreateSolidBrush(RGB(255, 255, 0));\r
- WhitePen = CreatePen(PS_SOLID, 1, RGB(255, 255, 255));\r
-\r
- CursorAPen = CreatePen(PS_DASH, 1, RGB(255, 255, 0));\r
- CursorBPen = CreatePen(PS_DASH, 1, RGB(255, 0, 255));\r
-\r
- MSG msg;\r
- for(;;) {\r
- if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {\r
- if(msg.message == WM_KEYDOWN && msg.wParam == VK_RETURN) {\r
- char got[1024];\r
- SendMessage(CommandEdit, WM_GETTEXT, (WPARAM)sizeof(got),\r
- (LPARAM)got);\r
-\r
- if(strcmp(got, "cls")==0) {\r
- SendMessage(ScrollbackEdit, WM_SETTEXT, 0, (LPARAM)"");\r
- } else {\r
- CommandReceived(got);\r
- }\r
- SendMessage(CommandEdit, WM_SETTEXT, 0, (LPARAM)"");\r
-\r
- // Insert it into the command history, unless it is\r
- // identical to the previous command in the history.\r
- int prev = CommandHistoryNext - 1;\r
- if(prev < 0) prev += COMMAND_HISTORY_MAX;\r
- if(strcmp(CommandHistory[prev], got) != 0) {\r
- strcpy(CommandHistory[CommandHistoryNext], got);\r
- CommandHistoryNext++;\r
- if(CommandHistoryNext == COMMAND_HISTORY_MAX) {\r
- CommandHistoryNext = 0;\r
- }\r
- }\r
- CommandHistoryPos = -1;\r
- } else if(msg.message == WM_KEYDOWN && msg.wParam == VK_UP &&\r
- msg.hwnd == CommandEdit)\r
- {\r
- if(CommandHistoryPos == -1) {\r
- CommandHistoryPos = CommandHistoryNext;\r
- }\r
- CommandHistoryPos--;\r
- if(CommandHistoryPos < 0) {\r
- CommandHistoryPos = COMMAND_HISTORY_MAX-1;\r
- }\r
- SetCommandEditTo(CommandHistory[CommandHistoryPos]);\r
- } else if(msg.message == WM_KEYDOWN && msg.wParam == VK_DOWN &&\r
- msg.hwnd == CommandEdit)\r
- {\r
- CommandHistoryPos++;\r
- if(CommandHistoryPos >= COMMAND_HISTORY_MAX) {\r
- CommandHistoryPos = 0;\r
- }\r
- SetCommandEditTo(CommandHistory[CommandHistoryPos]);\r
- } else if(msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE &&\r
- msg.hwnd == CommandEdit)\r
- {\r
- SendMessage(CommandEdit, WM_SETTEXT, 0, (LPARAM)"");\r
- } else {\r
- if(msg.message == WM_KEYDOWN) {\r
- CommandHistoryPos = -1;\r
- }\r
- TranslateMessage(&msg);\r
- DispatchMessage(&msg);\r
- }\r
- }\r
-\r
- if (!offline)\r
- {\r
- UsbCommand c;\r
- if(ReceiveCommandPoll(&c))\r
- UsbCommandReceived(&c);\r
- }\r
-\r
- Sleep(10);\r
- }\r
-}\r
+++ /dev/null
-/*++\r
-\r
-Copyright (c) 1996-1998 Microsoft Corporation\r
-\r
-Module Name:\r
-\r
- HIDPI.H\r
-\r
-Abstract:\r
-\r
- Public Interface to the HID parsing library.\r
-\r
-Environment:\r
-\r
- Kernel & user mode\r
-\r
---*/\r
-\r
-#ifndef __HIDPI_H__\r
-#define __HIDPI_H__\r
-\r
-#include <pshpack4.h>\r
-\r
-// Please include "hidsdi.h" to use the user space (dll / parser)\r
-// Please include "hidpddi.h" to use the kernel space parser\r
-\r
-//\r
-// Special Link collection values for using the query functions\r
-//\r
-// Root collection references the collection at the base of the link\r
-// collection tree.\r
-// Unspecifies, references all collections in the link collection tree.\r
-//\r
-#define HIDP_LINK_COLLECTION_ROOT ((USHORT) -1)\r
-#define HIDP_LINK_COLLECTION_UNSPECIFIED ((USHORT) 0)\r
-\r
-\r
-typedef enum _HIDP_REPORT_TYPE\r
-{\r
- HidP_Input,\r
- HidP_Output,\r
- HidP_Feature\r
-} HIDP_REPORT_TYPE;\r
-\r
-typedef struct _USAGE_AND_PAGE\r
-{\r
- USAGE Usage;\r
- USAGE UsagePage;\r
-} USAGE_AND_PAGE, *PUSAGE_AND_PAGE;\r
-\r
-#define HidP_IsSameUsageAndPage(u1, u2) ((* (PULONG) &u1) == (* (PULONG) &u2))\r
-\r
-typedef struct _HIDP_BUTTON_CAPS\r
-{\r
- USAGE UsagePage;\r
- UCHAR ReportID;\r
- BOOLEAN IsAlias;\r
-\r
- USHORT BitField;\r
- USHORT LinkCollection; // A unique internal index pointer\r
-\r
- USAGE LinkUsage;\r
- USAGE LinkUsagePage;\r
-\r
- BOOLEAN IsRange;\r
- BOOLEAN IsStringRange;\r
- BOOLEAN IsDesignatorRange;\r
- BOOLEAN IsAbsolute;\r
-\r
- ULONG Reserved[10];\r
- union {\r
- struct {\r
- USAGE UsageMin, UsageMax;\r
- USHORT StringMin, StringMax;\r
- USHORT DesignatorMin, DesignatorMax;\r
- USHORT DataIndexMin, DataIndexMax;\r
- } Range;\r
- struct {\r
- USAGE Usage, Reserved1;\r
- USHORT StringIndex, Reserved2;\r
- USHORT DesignatorIndex, Reserved3;\r
- USHORT DataIndex, Reserved4;\r
- } NotRange;\r
- };\r
-\r
-} HIDP_BUTTON_CAPS, *PHIDP_BUTTON_CAPS;\r
-\r
-\r
-typedef struct _HIDP_VALUE_CAPS\r
-{\r
- USAGE UsagePage;\r
- UCHAR ReportID;\r
- BOOLEAN IsAlias;\r
-\r
- USHORT BitField;\r
- USHORT LinkCollection; // A unique internal index pointer\r
-\r
- USAGE LinkUsage;\r
- USAGE LinkUsagePage;\r
-\r
- BOOLEAN IsRange;\r
- BOOLEAN IsStringRange;\r
- BOOLEAN IsDesignatorRange;\r
- BOOLEAN IsAbsolute;\r
-\r
- BOOLEAN HasNull; // Does this channel have a null report union\r
- UCHAR Reserved;\r
- USHORT BitSize; // How many bits are devoted to this value?\r
-\r
- USHORT ReportCount; // See Note below. Usually set to 1.\r
- USHORT Reserved2[5];\r
-\r
- ULONG UnitsExp;\r
- ULONG Units;\r
-\r
- LONG LogicalMin, LogicalMax;\r
- LONG PhysicalMin, PhysicalMax;\r
-\r
- union {\r
- struct {\r
- USAGE UsageMin, UsageMax;\r
- USHORT StringMin, StringMax;\r
- USHORT DesignatorMin, DesignatorMax;\r
- USHORT DataIndexMin, DataIndexMax;\r
- } Range;\r
-\r
- struct {\r
- USAGE Usage, Reserved1;\r
- USHORT StringIndex, Reserved2;\r
- USHORT DesignatorIndex, Reserved3;\r
- USHORT DataIndex, Reserved4;\r
- } NotRange;\r
- };\r
-} HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;\r
-\r
-//\r
-// Notes:\r
-//\r
-// ReportCount: When a report descriptor declares an Input, Output, or\r
-// Feature main item with fewer usage declarations than the report count, then\r
-// the last usage applies to all remaining unspecified count in that main item.\r
-// (As an example you might have data that required many fields to describe,\r
-// possibly buffered bytes.) In this case, only one value cap structure is\r
-// allocated for these associtated fields, all with the same usage, and Report\r
-// Count reflects the number of fields involved. Normally ReportCount is 1.\r
-// To access all of the fields in such a value structure would require using\r
-// HidP_GetUsageValueArray and HidP_SetUsageValueArray. HidP_GetUsageValue/\r
-// HidP_SetScaledUsageValue will also work, however, these functions will only\r
-// work with the first field of the structure.\r
-//\r
-\r
-//\r
-// The link collection tree consists of an array of LINK_COLLECTION_NODES\r
-// where the index into this array is the same as the collection number.\r
-//\r
-// Given a collection A which contains a subcollection B, A is defined to be\r
-// the parent B, and B is defined to be the child.\r
-//\r
-// Given collections A, B, and C where B and C are children of A, and B was\r
-// encountered before C in the report descriptor, B is defined as a sibling of\r
-// C. (This implies, of course, that if B is a sibling of C, then C is NOT a\r
-// sibling of B).\r
-//\r
-// B is defined as the NextSibling of C if and only if there exists NO\r
-// child collection of A, call it D, such that B is a sibling of D and D\r
-// is a sibling of C.\r
-//\r
-// E is defined to be the FirstChild of A if and only if for all children of A,\r
-// F, that are not equivalent to E, F is a sibling of E.\r
-// (This implies, of course, that the does not exist a child of A, call it G,\r
-// where E is a sibling of G). In other words the first sibling is the last\r
-// link collection found in the list.\r
-//\r
-// In other words, if a collection B is defined within the definition of another\r
-// collection A, B becomes a child of A. All collections with the same parent\r
-// are considered siblings. The FirstChild of the parent collection, A, will be\r
-// last collection defined that has A as a parent. The order of sibling pointers\r
-// is similarly determined. When a collection B is defined, it becomes the\r
-// FirstChild of it's parent collection. The previously defined FirstChild of the\r
-// parent collection becomes the NextSibling of the new collection. As new\r
-// collections with the same parent are discovered, the chain of sibling is built.\r
-//\r
-// With that in mind, the following describes conclusively a data structure\r
-// that provides direct traversal up, down, and accross the link collection\r
-// tree.\r
-//\r
-//\r
-typedef struct _HIDP_LINK_COLLECTION_NODE\r
-{\r
- USAGE LinkUsage;\r
- USAGE LinkUsagePage;\r
- USHORT Parent;\r
- USHORT NumberOfChildren;\r
- USHORT NextSibling;\r
- USHORT FirstChild;\r
- ULONG CollectionType: 8; // As defined in 6.2.2.6 of HID spec\r
- ULONG IsAlias : 1; // This link node is an allias of the next link node.\r
- ULONG Reserved: 23;\r
- PVOID UserContext; // The user can hang his coat here.\r
-} HIDP_LINK_COLLECTION_NODE, *PHIDP_LINK_COLLECTION_NODE;\r
-\r
-//\r
-// When a link collection is described by a delimiter, alias link collection\r
-// nodes are created. (One for each usage within the delimiter).\r
-// The parser assigns each capability description listed above only one\r
-// link collection.\r
-//\r
-// If a control is defined within a collection defined by\r
-// delimited usages, then that control is said to be within multiple link\r
-// collections, one for each usage within the open and close delimiter tokens.\r
-// Such multiple link collecions are said to be aliases. The first N-1 such\r
-// collections, listed in the link collection node array, have their IsAlias\r
-// bit set. The last such link collection is the link collection index used\r
-// in the capabilities described above.\r
-// Clients wishing to set a control in an aliased collection, should walk the\r
-// collection array once for each time they see the IsAlias flag set, and use\r
-// the last link collection as the index for the below accessor functions.\r
-//\r
-// NB: if IsAlias is set, then NextSibling should be one more than the current\r
-// link collection node index.\r
-//\r
-\r
-typedef PUCHAR PHIDP_REPORT_DESCRIPTOR;\r
-typedef struct _HIDP_PREPARSED_DATA * PHIDP_PREPARSED_DATA;\r
-\r
-typedef struct _HIDP_CAPS\r
-{\r
- USAGE Usage;\r
- USAGE UsagePage;\r
- USHORT InputReportByteLength;\r
- USHORT OutputReportByteLength;\r
- USHORT FeatureReportByteLength;\r
- USHORT Reserved[17];\r
-\r
- USHORT NumberLinkCollectionNodes;\r
-\r
- USHORT NumberInputButtonCaps;\r
- USHORT NumberInputValueCaps;\r
- USHORT NumberInputDataIndices;\r
-\r
- USHORT NumberOutputButtonCaps;\r
- USHORT NumberOutputValueCaps;\r
- USHORT NumberOutputDataIndices;\r
-\r
- USHORT NumberFeatureButtonCaps;\r
- USHORT NumberFeatureValueCaps;\r
- USHORT NumberFeatureDataIndices;\r
-} HIDP_CAPS, *PHIDP_CAPS;\r
-\r
-typedef struct _HIDP_DATA\r
-{\r
- USHORT DataIndex;\r
- USHORT Reserved;\r
- union {\r
- ULONG RawValue; // for values\r
- BOOLEAN On; // for buttons MUST BE TRUE for buttons.\r
- };\r
-} HIDP_DATA, *PHIDP_DATA;\r
-//\r
-// The HIDP_DATA structure is used with HidP_GetData and HidP_SetData\r
-// functions.\r
-//\r
-// The parser contiguously assigns every control (button or value) in a hid\r
-// device a unique data index from zero to NumberXXXDataIndices -1 , inclusive.\r
-// This value is found in the HIDP_BUTTON_CAPS and HIDP_VALUE_CAPS structures.\r
-//\r
-// Most clients will find the Get/Set Buttons / Value accessor functions\r
-// sufficient to their needs, as they will allow the clients to access the\r
-// data known to them while ignoring the other controls.\r
-//\r
-// More complex clients, which actually read the Button / Value Caps, and which\r
-// do a value add service to these routines (EG Direct Input), will need to\r
-// access all the data in the device without interest in the individual usage\r
-// or link collection location. These are the clients that will find\r
-// HidP_Data useful.\r
-//\r
-\r
-typedef struct _HIDP_UNKNOWN_TOKEN\r
-{\r
- UCHAR Token;\r
- UCHAR Reserved[3];\r
- ULONG BitField;\r
-} HIDP_UNKNOWN_TOKEN, *PHIDP_UNKNOWN_TOKEN;\r
-\r
-typedef struct _HIDP_EXTENDED_ATTRIBUTES\r
-{\r
- UCHAR NumGlobalUnknowns;\r
- UCHAR Reserved [3];\r
- PHIDP_UNKNOWN_TOKEN GlobalUnknowns;\r
- // ... Additional attributes\r
- ULONG Data [1]; // variableLength DO NOT ACCESS THIS FIELD\r
-} HIDP_EXTENDED_ATTRIBUTES, *PHIDP_EXTENDED_ATTRIBUTES;\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetCaps (\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- OUT PHIDP_CAPS Capabilities\r
- );\r
-/*++\r
-Routine Description:\r
- Returns a list of capabilities of a given hid device as described by its\r
- preparsed data.\r
-\r
-Arguments:\r
- PreparsedData The preparsed data returned from HIDCLASS.\r
- Capabilities a HIDP_CAPS structure\r
-\r
-Return Value:\r
-· HIDP_STATUS_SUCCESS\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetLinkCollectionNodes (\r
- OUT PHIDP_LINK_COLLECTION_NODE LinkCollectionNodes,\r
- IN OUT PULONG LinkCollectionNodesLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
- );\r
-/*++\r
-Routine Description:\r
- Return a list of PHIDP_LINK_COLLECTION_NODEs used to describe the link\r
- collection tree of this hid device. See the above description of\r
- struct _HIDP_LINK_COLLECTION_NODE.\r
-\r
-Arguments:\r
- LinkCollectionNodes - a caller allocated array into which\r
- HidP_GetLinkCollectionNodes will store the information\r
-\r
- LinKCollectionNodesLength - the caller sets this value to the length of the\r
- the array in terms of number of elements.\r
- HidP_GetLinkCollectionNodes sets this value to the actual\r
- number of elements set. The total number of nodes required to\r
- describe this HID device can be found in the\r
- NumberLinkCollectionNodes field in the HIDP_CAPS structure.\r
-\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetButtonCaps (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- OUT PHIDP_BUTTON_CAPS ButtonCaps,\r
- IN OUT PUSHORT ButtonCapsLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
-);\r
-#define HidP_GetButtonCaps(_Type_, _Caps_, _Len_, _Data_) \\r
- HidP_GetSpecificButtonCaps (_Type_, 0, 0, 0, _Caps_, _Len_, _Data_)\r
-NTSTATUS __stdcall\r
-HidP_GetSpecificButtonCaps (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage, // Optional (0 => ignore)\r
- IN USHORT LinkCollection, // Optional (0 => ignore)\r
- IN USAGE Usage, // Optional (0 => ignore)\r
- OUT PHIDP_BUTTON_CAPS ButtonCaps,\r
- IN OUT PUSHORT ButtonCapsLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
- );\r
-/*++\r
-Description:\r
- HidP_GetButtonCaps returns all the buttons (binary values) that are a part\r
- of the given report type for the Hid device represented by the given\r
- preparsed data.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
-\r
- UsagePage A usage page value used to limit the button caps returned to\r
- those on a given usage page. If set to 0, this parameter is\r
- ignored. Can be used with LinkCollection and Usage parameters\r
- to further limit the number of button caps structures returned.\r
-\r
- LinkCollection HIDP_LINK_COLLECTION node array index used to limit the\r
- button caps returned to those buttons in a given link\r
- collection. If set to 0, this parameter is\r
- ignored. Can be used with UsagePage and Usage parameters\r
- to further limit the number of button caps structures\r
- returned.\r
-\r
- Usage A usage value used to limit the button caps returned to those\r
- with the specified usage value. If set to 0, this parameter\r
- is ignored. Can be used with LinkCollection and UsagePage\r
- parameters to further limit the number of button caps\r
- structures returned.\r
-\r
- ButtonCaps A _HIDP_BUTTON_CAPS array containing information about all the\r
- binary values in the given report. This buffer is provided by\r
- the caller.\r
-\r
- ButtonLength As input, this parameter specifies the length of the\r
- ButtonCaps parameter (array) in number of array elements.\r
- As output, this value is set to indicate how many of those\r
- array elements were filled in by the function. The maximum number of\r
- button caps that can be returned is found in the HIDP_CAPS\r
- structure. If HIDP_STATUS_BUFFER_TOO_SMALL is returned,\r
- this value contains the number of array elements needed to\r
- successfully complete the request.\r
-\r
- PreparsedData The preparsed data returned from HIDCLASS.\r
-\r
-\r
-Return Value\r
-HidP_GetSpecificButtonCaps returns the following error codes:\r
-· HIDP_STATUS_SUCCESS.\r
-· HIDP_STATUS_INVALID_REPORT_TYPE\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA\r
-· HIDP_STATUS_BUFFER_TOO_SMALL (all given entries however have been filled in)\r
-· HIDP_STATUS_USAGE_NOT_FOUND\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetValueCaps (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- OUT PHIDP_VALUE_CAPS ValueCaps,\r
- IN OUT PUSHORT ValueCapsLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
-);\r
-#define HidP_GetValueCaps(_Type_, _Caps_, _Len_, _Data_) \\r
- HidP_GetSpecificValueCaps (_Type_, 0, 0, 0, _Caps_, _Len_, _Data_)\r
-NTSTATUS __stdcall\r
-HidP_GetSpecificValueCaps (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage, // Optional (0 => ignore)\r
- IN USHORT LinkCollection, // Optional (0 => ignore)\r
- IN USAGE Usage, // Optional (0 => ignore)\r
- OUT PHIDP_VALUE_CAPS ValueCaps,\r
- IN OUT PUSHORT ValueCapsLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
- );\r
-/*++\r
-Description:\r
- HidP_GetValueCaps returns all the values (non-binary) that are a part\r
- of the given report type for the Hid device represented by the given\r
- preparsed data.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
-\r
- UsagePage A usage page value used to limit the value caps returned to\r
- those on a given usage page. If set to 0, this parameter is\r
- ignored. Can be used with LinkCollection and Usage parameters\r
- to further limit the number of value caps structures returned.\r
-\r
- LinkCollection HIDP_LINK_COLLECTION node array index used to limit the\r
- value caps returned to those buttons in a given link\r
- collection. If set to 0, this parameter is\r
- ignored. Can be used with UsagePage and Usage parameters\r
- to further limit the number of value caps structures\r
- returned.\r
-\r
- Usage A usage value used to limit the value caps returned to those\r
- with the specified usage value. If set to 0, this parameter\r
- is ignored. Can be used with LinkCollection and UsagePage\r
- parameters to further limit the number of value caps\r
- structures returned.\r
-\r
- ValueCaps A _HIDP_VALUE_CAPS array containing information about all the\r
- non-binary values in the given report. This buffer is provided\r
- by the caller.\r
-\r
- ValueLength As input, this parameter specifies the length of the ValueCaps\r
- parameter (array) in number of array elements. As output,\r
- this value is set to indicate how many of those array elements\r
- were filled in by the function. The maximum number of\r
- value caps that can be returned is found in the HIDP_CAPS\r
- structure. If HIDP_STATUS_BUFFER_TOO_SMALL is returned,\r
- this value contains the number of array elements needed to\r
- successfully complete the request.\r
-\r
- PreparsedData The preparsed data returned from HIDCLASS.\r
-\r
-\r
-Return Value\r
-HidP_GetValueCaps returns the following error codes:\r
-· HIDP_STATUS_SUCCESS.\r
-· HIDP_STATUS_INVALID_REPORT_TYPE\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA\r
-· HIDP_STATUS_BUFFER_TOO_SMALL (all given entries however have been filled in)\r
-· HIDP_STATUS_USAGE_NOT_FOUND\r
-\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetExtendedAttributes (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USHORT DataIndex,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- OUT PHIDP_EXTENDED_ATTRIBUTES Attributes,\r
- IN OUT PULONG LengthAttributes\r
- );\r
-/*++\r
-Description:\r
- Given a data index from the value or button capabilities of a given control\r
- return any extended attributes for the control if any exist.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
-\r
- DataIndex The data index for the given control, found in the capabilities\r
- structure for that control\r
-\r
- PreparsedData The preparsed data returned from HIDCLASS.\r
-\r
- Attributes Pointer to a buffer into which the extended attribute data will\r
- be copied.\r
-\r
- LengthAttributes Length of the given buffer in bytes.\r
-\r
-Return Value\r
- HIDP_STATUS_SUCCESS\r
- HIDP_STATUS_DATA_INDEX_NOT_FOUND\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_InitializeReportForID (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN UCHAR ReportID,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN OUT PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Initialize a report based on the given report ID.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
-\r
- PreparasedData Preparsed data structure returned by HIDCLASS\r
-\r
- Report Buffer which to set the data into.\r
-\r
- ReportLength Length of Report...Report should be at least as long as the\r
- value indicated in the HIDP_CAPS structure for the device and\r
- the corresponding ReportType\r
-\r
-Return Value\r
-\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal\r
- to the length specified in HIDP_CAPS\r
- structure for the given ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_SetData (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN PHIDP_DATA DataList,\r
- IN OUT PULONG DataLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN OUT PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Please Note: Since usage value arrays deal with multiple fields for\r
- for one usage value, they cannot be used with HidP_SetData\r
- and HidP_GetData. In this case,\r
- HIDP_STATUS_IS_USAGE_VALUE_ARRAY will be returned.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
-\r
- DataList Array of HIDP_DATA structures that contains the data values\r
- that are to be set into the given report\r
-\r
- DataLength As input, length in array elements of DataList. As output,\r
- contains the number of data elements set on successful\r
- completion or an index into the DataList array to identify\r
- the faulting HIDP_DATA value if an error code is returned.\r
-\r
- PreparasedData Preparsed data structure returned by HIDCLASS\r
-\r
- Report Buffer which to set the data into.\r
-\r
- ReportLength Length of Report...Report should be at least as long as the\r
- value indicated in the HIDP_CAPS structure for the device and\r
- the corresponding ReportType\r
-\r
-Return Value\r
- HidP_SetData returns the following error codes. The report packet will\r
- have all the data set up until the HIDP_DATA structure that caused the\r
- error. DataLength, in the error case, will return this problem index.\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successful insertion of all data\r
- into the report packet.\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_DATA_INDEX_NOT_FOUND -- if a HIDP_DATA structure referenced a\r
- data index that does not exist for this\r
- device's ReportType\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal\r
- to the length specified in HIDP_CAPS\r
- structure for the given ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_IS_USAGE_VALUE_ARRAY -- if one of the HIDP_DATA structures\r
- references a usage value array.\r
- DataLength will contain the index into\r
- the array that was invalid\r
-· HIDP_STATUS_BUTTON_NOT_PRESSED -- if a HIDP_DATA structure attempted\r
- to unset a button that was not already\r
- set in the Report\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- a HIDP_DATA structure was found with\r
- a valid index value but is contained\r
- in a different report than the one\r
- currently being processed\r
-· HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough entries in\r
- a given Main Array Item to report all\r
- buttons that have been requested to be\r
- set\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetData (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- OUT PHIDP_DATA DataList,\r
- IN OUT PULONG DataLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Please Note: For obvious reasons HidP_SetData and HidP_GetData will not\r
- access UsageValueArrays.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output, or HidP_Feature.\r
-\r
- DataList Array of HIDP_DATA structures that will receive the data\r
- values that are set in the given report\r
-\r
- DataLength As input, length in array elements of DataList. As output,\r
- contains the number of data elements that were successfully\r
- set by HidP_GetData. The maximum size necessary for DataList\r
- can be determined by calling HidP_MaxDataListLength\r
-\r
- PreparasedData Preparsed data structure returned by HIDCLASS\r
-\r
- Report Buffer which to set the data into.\r
-\r
- ReportLength Length of Report...Report should be at least as long as the\r
- value indicated in the HIDP_CAPS structure for the device and\r
- the corresponding ReportType\r
-\r
-Return Value\r
- HidP_GetData returns the following error codes.\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successful retrieval of all data\r
- from the report packet.\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal\r
- to the length specified in HIDP_CAPS\r
- structure for the given ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough array entries in\r
- DataList to store all the indice values\r
- in the given report. DataLength will\r
- contain the number of array entries\r
- required to hold all data\r
---*/\r
-\r
-ULONG __stdcall\r
-HidP_MaxDataListLength (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
- );\r
-/*++\r
-Routine Description:\r
-\r
- This function returns the maximum length of HIDP_DATA elements that\r
- HidP_GetData could return for the given report type.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
-\r
- PreparsedData Preparsed data structure returned by HIDCLASS\r
-\r
-Return Value:\r
-\r
- The length of the data list array required for the HidP_GetData function\r
- call. If an error occurs (either HIDP_STATUS_INVALID_REPORT_TYPE or\r
- HIDP_STATUS_INVALID_PREPARSED_DATA), this function returns 0.\r
-\r
---*/\r
-\r
-#define HidP_SetButtons(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) \\r
- HidP_SetUsages(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle)\r
-\r
-NTSTATUS __stdcall\r
-HidP_SetUsages (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN PUSAGE UsageList,\r
- IN OUT PULONG UsageLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN OUT PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-/*++\r
-\r
-Routine Description:\r
- This function sets binary values (buttons) in a report. Given an\r
- initialized packet of correct length, it modifies the report packet so that\r
- each element in the given list of usages has been set in the report packet.\r
- For example, in an output report with 5 LED\92s, each with a given usage,\r
- an application could turn on any subset of these lights by placing their\r
- usages in any order into the usage array (UsageList). HidP_SetUsages would,\r
- in turn, set the appropriate bit or add the corresponding byte into the\r
- HID Main Array Item.\r
-\r
- A properly initialized Report packet is one of the correct byte length,\r
- and all zeros.\r
-\r
- NOTE: A packet that has already been set with a call to a HidP_Set routine\r
- can also be passed in. This routine then sets processes the UsageList\r
- in the same fashion but verifies that the ReportID already set in\r
- Report matches the report ID for the given usages.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
-\r
- UsagePage All of the usages in the usage array, which HidP_SetUsages will\r
- set in the report, refer to this same usage page.\r
- If a client wishes to set usages in a report for multiple\r
- usage pages then that client needs to make multiple calls to\r
- HidP_SetUsages for each of the usage pages.\r
-\r
- UsageList A usage array containing the usages that HidP_SetUsages will set in\r
- the report packet.\r
-\r
- UsageLength The length of the given usage array in array elements.\r
- The parser will set this value to the position in the usage\r
- array where it stopped processing. If successful, UsageLength\r
- will be unchanged. In any error condition, this parameter\r
- reflects how many of the usages in the usage list have\r
- actually been set by the parser. This is useful for finding\r
- the usage in the list which caused the error.\r
-\r
- PreparsedData The preparsed data recevied from HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length of the given report packet...Must be equal to the\r
- value reported in the HIDP_CAPS structure for the device\r
- and corresponding report type.\r
-\r
-Return Value\r
- HidP_SetUsages returns the following error codes. On error, the report packet\r
- will be correct up until the usage element that caused the error.\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successful insertion of all usages\r
- into the report packet.\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if a usage was found that exists in a\r
- different report. If the report is\r
- zero-initialized on entry the first\r
- usage in the list will determine which\r
- report ID is used. Otherwise, the\r
- parser will verify that usage matches\r
- the passed in report's ID\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage does not exist for any\r
- report (no matter what the report ID)\r
- for the given report type.\r
-· HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough entries in a\r
- given Main Array Item to list all of\r
- the given usages. The caller needs\r
- to split his request into more than\r
- one call\r
---*/\r
-\r
-#define HidP_UnsetButtons(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) \\r
- HidP_UnsetUsages(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle)\r
-\r
-NTSTATUS __stdcall\r
-HidP_UnsetUsages (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN PUSAGE UsageList,\r
- IN OUT PULONG UsageLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN OUT PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-/*++\r
-\r
-Routine Description:\r
- This function unsets (turns off) binary values (buttons) in the report. Given\r
- an initialized packet of correct length, it modifies the report packet so\r
- that each element in the given list of usages has been unset in the\r
- report packet.\r
-\r
- This function is the "undo" operation for SetUsages. If the given usage\r
- is not already set in the Report, it will return an error code of\r
- HIDP_STATUS_BUTTON_NOT_PRESSED. If the button is pressed, HidP_UnsetUsages\r
- will unset the appropriate bit or remove the corresponding index value from\r
- the HID Main Array Item.\r
-\r
- A properly initialized Report packet is one of the correct byte length,\r
- and all zeros..\r
-\r
- NOTE: A packet that has already been set with a call to a HidP_Set routine\r
- can also be passed in. This routine then processes the UsageList\r
- in the same fashion but verifies that the ReportID already set in\r
- Report matches the report ID for the given usages.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
-\r
- UsagePage All of the usages in the usage array, which HidP_UnsetUsages will\r
- unset in the report, refer to this same usage page.\r
- If a client wishes to unset usages in a report for multiple\r
- usage pages then that client needs to make multiple calls to\r
- HidP_UnsetUsages for each of the usage pages.\r
-\r
- UsageList A usage array containing the usages that HidP_UnsetUsages will\r
- unset in the report packet.\r
-\r
- UsageLength The length of the given usage array in array elements.\r
- The parser will set this value to the position in the usage\r
- array where it stopped processing. If successful, UsageLength\r
- will be unchanged. In any error condition, this parameter\r
- reflects how many of the usages in the usage list have\r
- actually been unset by the parser. This is useful for finding\r
- the usage in the list which caused the error.\r
-\r
- PreparsedData The preparsed data recevied from HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length of the given report packet...Must be equal to the\r
- value reported in the HIDP_CAPS structure for the device\r
- and corresponding report type.\r
-\r
-Return Value\r
- HidP_UnsetUsages returns the following error codes. On error, the report\r
- packet will be correct up until the usage element that caused the error.\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successful "unsetting" of all usages\r
- in the report packet.\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if a usage was found that exists in a\r
- different report. If the report is\r
- zero-initialized on entry the first\r
- usage in the list will determine which\r
- report ID is used. Otherwise, the\r
- parser will verify that usage matches\r
- the passed in report's ID\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage does not exist for any\r
- report (no matter what the report ID)\r
- for the given report type.\r
-· HIDP_STATUS_BUTTON_NOT_PRESSED -- if a usage corresponds to a button that\r
- is not already set in the given report\r
---*/\r
-\r
-#define HidP_GetButtons(Rty, UPa, LCo, ULi, ULe, Ppd, Rep, RLe) \\r
- HidP_GetUsages(Rty, UPa, LCo, ULi, ULe, Ppd, Rep, RLe)\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetUsages (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- OUT USAGE * UsageList,\r
- IN OUT ULONG * UsageLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-/*++\r
-\r
-Routine Description:\r
- This function returns the binary values (buttons) that are set in a HID\r
- report. Given a report packet of correct length, it searches the report\r
- packet for each usage for the given usage page and returns them in the\r
- usage list.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
-\r
- UsagePage All of the usages in the usage list, which HidP_GetUsages will\r
- retrieve in the report, refer to this same usage page.\r
- If the client wishes to get usages in a packet for multiple\r
- usage pages then that client needs to make multiple calls\r
- to HidP_GetUsages.\r
-\r
- LinkCollection An optional value which can limit which usages are returned\r
- in the UsageList to those usages that exist in a specific\r
- LinkCollection. A non-zero value indicates the index into\r
- the HIDP_LINK_COLLECITON_NODE list returned by\r
- HidP_GetLinkCollectionNodes of the link collection the\r
- usage should belong to. A value of 0 indicates this\r
- should value be ignored.\r
-\r
- UsageList The usage array that will contain all the usages found in\r
- the report packet.\r
-\r
- UsageLength The length of the given usage array in array elements.\r
- On input, this value describes the length of the usage list.\r
- On output, HidP_GetUsages sets this value to the number of\r
- usages that was found. Use HidP_MaxUsageListLength to\r
- determine the maximum length needed to return all the usages\r
- that a given report packet may contain.\r
-\r
- PreparsedData Preparsed data structure returned by HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length (in bytes) of the given report packet\r
-\r
-\r
-Return Value\r
- HidP_GetUsages returns the following error codes:\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successfully retrieving all the\r
- usages from the report packet\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_BUFFER_TOO_SMALL -- if the UsageList is not big enough to\r
- hold all the usages found in the report\r
- packet. If this is returned, the buffer\r
- will contain UsageLength number of\r
- usages. Use HidP_MaxUsageListLength to\r
- find the maximum length needed\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if no usages were found but usages\r
- that match the UsagePage and\r
- LinkCollection specified could be found\r
- in a report with a different report ID\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if there are no usages in a reports for\r
- the device and ReportType that match the\r
- UsagePage and LinkCollection that were\r
- specified\r
---*/\r
-\r
-#define HidP_GetButtonsEx(Rty, LCo, BLi, ULe, Ppd, Rep, RLe) \\r
- HidP_GetUsagesEx(Rty, LCo, BLi, ULe, Ppd, Rep, RLe)\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetUsagesEx (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USHORT LinkCollection, // Optional\r
- OUT PUSAGE_AND_PAGE ButtonList,\r
- IN OUT ULONG * UsageLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-\r
-/*++\r
-\r
-Routine Description:\r
- This function returns the binary values (buttons) in a HID report.\r
- Given a report packet of correct length, it searches the report packet\r
- for all buttons and returns the UsagePage and Usage for each of the buttons\r
- it finds.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
-\r
- LinkCollection An optional value which can limit which usages are returned\r
- in the ButtonList to those usages that exist in a specific\r
- LinkCollection. A non-zero value indicates the index into\r
- the HIDP_LINK_COLLECITON_NODE list returned by\r
- HidP_GetLinkCollectionNodes of the link collection the\r
- usage should belong to. A value of 0 indicates this\r
- should value be ignored.\r
-\r
- ButtonList An array of USAGE_AND_PAGE structures describing all the\r
- buttons currently ``down'' in the device.\r
-\r
- UsageLength The length of the given array in terms of elements.\r
- On input, this value describes the length of the list. On\r
- output, HidP_GetUsagesEx sets this value to the number of\r
- usages that were found. Use HidP_MaxUsageListLength to\r
- determine the maximum length needed to return all the usages\r
- that a given report packet may contain.\r
-\r
- PreparsedData Preparsed data returned by HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length (in bytes) of the given report packet.\r
-\r
-\r
-Return Value\r
- HidP_GetUsagesEx returns the following error codes:\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successfully retrieving all the\r
- usages from the report packet\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_BUFFER_TOO_SMALL -- if ButtonList is not big enough to\r
- hold all the usages found in the report\r
- packet. If this is returned, the buffer\r
- will contain UsageLength number of\r
- usages. Use HidP_MaxUsageListLength to\r
- find the maximum length needed\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if no usages were found but usages\r
- that match the specified LinkCollection\r
- exist in report with a different report\r
- ID.\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if there are no usages in any reports that\r
- match the LinkCollection parameter\r
---*/\r
-\r
-#define HidP_GetButtonListLength(RTy, UPa, Ppd) \\r
- HidP_GetUsageListLength(Rty, UPa, Ppd)\r
-\r
-ULONG __stdcall\r
-HidP_MaxUsageListLength (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage, // Optional\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
- );\r
-/*++\r
-Routine Description:\r
- This function returns the maximum number of usages that a call to\r
- HidP_GetUsages or HidP_GetUsagesEx could return for a given HID report.\r
- If calling for number of usages returned by HidP_GetUsagesEx, use 0 as\r
- the UsagePage value.\r
-\r
-Parameters:\r
- ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
-\r
- UsagePage Specifies the optional UsagePage to query for. If 0, will\r
- return all the maximum number of usage values that could be\r
- returned for a given ReportType. If non-zero, will return\r
- the maximum number of usages that would be returned for the\r
- ReportType with the given UsagePage.\r
-\r
- PreparsedData Preparsed data returned from HIDCLASS\r
-\r
-Return Value:\r
- The length of the usage list array required for the HidP_GetUsages or\r
- HidP_GetUsagesEx function call. If an error occurs (such as\r
- HIDP_STATUS_INVALID_REPORT_TYPE or HIDP_INVALID_PREPARSED_DATA, this\r
- returns 0.\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_SetUsageValue (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN USAGE Usage,\r
- IN ULONG UsageValue,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN OUT PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-/*++\r
-Description:\r
- HidP_SetUsageValue inserts a value into the HID Report Packet in the field\r
- corresponding to the given usage page and usage. HidP_SetUsageValue\r
- casts this value to the appropriate bit length. If a report packet\r
- contains two different fields with the same Usage and UsagePage,\r
- they can be distinguished with the optional LinkCollection field value.\r
- Using this function sets the raw value into the report packet with\r
- no checking done as to whether it actually falls within the logical\r
- minimum/logical maximum range. Use HidP_SetScaledUsageValue for this...\r
-\r
- NOTE: Although the UsageValue parameter is a ULONG, any casting that is\r
- done will preserve or sign-extend the value. The value being set\r
- should be considered a LONG value and will be treated as such by\r
- this function.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Output or HidP_Feature.\r
-\r
- UsagePage The usage page to which the given usage refers.\r
-\r
- LinkCollection (Optional) This value can be used to differentiate\r
- between two fields that may have the same\r
- UsagePage and Usage but exist in different\r
- collections. If the link collection value\r
- is zero, this function will set the first field\r
- it finds that matches the usage page and\r
- usage.\r
-\r
- Usage The usage whose value HidP_SetUsageValue will set.\r
-\r
- UsageValue The raw value to set in the report buffer. This value must be within\r
- the logical range or if a NULL value this value should be the\r
- most negative value that can be represented by the number of bits\r
- for this field.\r
-\r
- PreparsedData The preparsed data returned for HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length (in bytes) of the given report packet.\r
-\r
-\r
-Return Value:\r
- HidP_SetUsageValue returns the following error codes:\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successfully setting the value\r
- in the report packet\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
- link collection exist but exists in\r
- a report with a different report ID\r
- than the report being passed in. To\r
- set this value, call HidP_SetUsageValue\r
- again with a zero-initizialed report\r
- packet\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
- collection combination does not exist\r
- in any reports for this ReportType\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_SetScaledUsageValue (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN USAGE Usage,\r
- IN LONG UsageValue,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN OUT PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-\r
-/*++\r
-Description:\r
- HidP_SetScaledUsageValue inserts the UsageValue into the HID report packet\r
- in the field corresponding to the given usage page and usage. If a report\r
- packet contains two different fields with the same Usage and UsagePage,\r
- they can be distinguished with the optional LinkCollection field value.\r
-\r
- If the specified field has a defined physical range, this function converts\r
- the physical value specified to the corresponding logical value for the\r
- report. If a physical value does not exist, the function will verify that\r
- the value specified falls within the logical range and set according.\r
-\r
- If the range checking fails but the field has NULL values, the function will\r
- set the field to the defined NULL value (most negative number possible) and\r
- return HIDP_STATUS_NULL. In other words, use this function to set NULL\r
- values for a given field by passing in a value that falls outside the\r
- physical range if it is defined or the logical range otherwise.\r
-\r
- If the field does not support NULL values, an out of range error will be\r
- returned instead.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Output or HidP_Feature.\r
-\r
- UsagePage The usage page to which the given usage refers.\r
-\r
- LinkCollection (Optional) This value can be used to differentiate\r
- between two fields that may have the same\r
- UsagePage and Usage but exist in different\r
- collections. If the link collection value\r
- is zero, this function will set the first field\r
- it finds that matches the usage page and\r
- usage.\r
-\r
- Usage The usage whose value HidP_SetScaledUsageValue will set.\r
-\r
- UsageValue The value to set in the report buffer. See the routine\r
- description above for the different interpretations of this\r
- value\r
-\r
- PreparsedData The preparsed data returned from HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length (in bytes) of the given report packet.\r
-\r
-\r
-Return Value:\r
- HidP_SetScaledUsageValue returns the following error codes:\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successfully setting the value\r
- in the report packet\r
-· HIDP_STATUS_NULL -- upon successfully setting the value\r
- in the report packet as a NULL value\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_VALUE_OUT_OF_RANGE -- if the value specified failed to fall\r
- within the physical range if it exists\r
- or within the logical range otherwise\r
- and the field specified by the usage\r
- does not allow NULL values\r
-· HIDP_STATUS_BAD_LOG_PHY_VALUES -- if the field has a physical range but\r
- either the logical range is invalid\r
- (max <= min) or the physical range is\r
- invalid\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
- link collection exist but exists in\r
- a report with a different report ID\r
- than the report being passed in. To\r
- set this value, call\r
- HidP_SetScaledUsageValue again with\r
- a zero-initialized report packet\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
- collection combination does not exist\r
- in any reports for this ReportType\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_SetUsageValueArray (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN USAGE Usage,\r
- IN PCHAR UsageValue,\r
- IN USHORT UsageValueByteLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- OUT PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-\r
-/*++\r
-Routine Descripton:\r
- A usage value array occurs when the last usage in the list of usages\r
- describing a main item must be repeated because there are less usages defined\r
- than there are report counts declared for the given main item. In this case\r
- a single value cap is allocated for that usage and the report count of that\r
- value cap is set to reflect the number of fields to which that usage refers.\r
-\r
- HidP_SetUsageValueArray sets the raw bits for that usage which spans\r
- more than one field in a report.\r
-\r
- NOTE: This function currently does not support value arrays where the\r
- ReportSize for each of the fields in the array is not a multiple\r
- of 8 bits.\r
-\r
- The UsageValue buffer should have the values set as they would appear\r
- in the report buffer. If this function supported non 8-bit multiples\r
- for the ReportSize then caller should format the input buffer so that\r
- each new value begins at the bit immediately following the last bit\r
- of the previous value\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Output or HidP_Feature.\r
-\r
- UsagePage The usage page to which the given usage refers.\r
-\r
- LinkCollection (Optional) This value can be used to differentiate\r
- between two fields that may have the same\r
- UsagePage and Usage but exist in different\r
- collections. If the link collection value\r
- is zero, this function will set the first field\r
- it finds that matches the usage page and\r
- usage.\r
-\r
- Usage The usage whose value array HidP_SetUsageValueArray will set.\r
-\r
- UsageValue The buffer with the values to set into the value array.\r
- The number of BITS required is found by multiplying the\r
- BitSize and ReportCount fields of the Value Cap for this\r
- control. The least significant bit of this control found in the\r
- given report will be placed in the least significan bit location\r
- of the array given (little-endian format), regardless of whether\r
- or not the field is byte alligned or if the BitSize is a multiple\r
- of sizeof (CHAR).\r
-\r
- See the above note for current implementation limitations.\r
-\r
- UsageValueByteLength Length of the UsageValue buffer (in bytes)\r
-\r
- PreparsedData The preparsed data returned from HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length (in bytes) of the given report packet.\r
-\r
-\r
-Return Value:\r
-· HIDP_STATUS_SUCCESS -- upon successfully setting the value\r
- array in the report packet\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_NOT_VALUE_ARRAY -- if the control specified is not a\r
- value array -- a value array will have\r
- a ReportCount field in the\r
- HIDP_VALUE_CAPS structure that is > 1\r
- Use HidP_SetUsageValue instead\r
-· HIDP_STATUS_BUFFER_TOO_SMALL -- if the size of the passed in buffer with\r
- the values to set is too small (ie. has\r
- fewer values than the number of fields in\r
- the array\r
-· HIDP_STATUS_NOT_IMPLEMENTED -- if the usage value array has field sizes\r
- that are not multiples of 8 bits, this\r
- error code is returned since the function\r
- currently does not handle setting into\r
- such arrays.\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
- link collection exist but exists in\r
- a report with a different report ID\r
- than the report being passed in. To\r
- set this value, call\r
- HidP_SetUsageValueArray again with\r
- a zero-initialized report packet\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
- collection combination does not exist\r
- in any reports for this ReportType\r
---*/\r
-\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetUsageValue (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN USAGE Usage,\r
- OUT PULONG UsageValue,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-\r
-/*\r
-Description\r
- HidP_GetUsageValue retrieves the value from the HID Report for the usage\r
- specified by the combination of usage page, usage and link collection.\r
- If a report packet contains two different fields with the same\r
- Usage and UsagePage, they can be distinguished with the optional\r
- LinkCollection field value.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Input or HidP_Feature.\r
-\r
- UsagePage The usage page to which the given usage refers.\r
-\r
- LinkCollection (Optional) This value can be used to differentiate\r
- between two fields that may have the same\r
- UsagePage and Usage but exist in different\r
- collections. If the link collection value\r
- is zero, this function will set the first field\r
- it finds that matches the usage page and\r
- usage.\r
-\r
- Usage The usage whose value HidP_GetUsageValue will retrieve\r
-\r
- UsageValue The raw value that is set for the specified field in the report\r
- buffer. This value will either fall within the logical range\r
- or if NULL values are allowed, a number outside the range to\r
- indicate a NULL\r
-\r
- PreparsedData The preparsed data returned for HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length (in bytes) of the given report packet.\r
-\r
-\r
-Return Value:\r
- HidP_GetUsageValue returns the following error codes:\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successfully retrieving the value\r
- from the report packet\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device\r
- for the given ReportType\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
- link collection exist but exists in\r
- a report with a different report ID\r
- than the report being passed in. To\r
- set this value, call HidP_GetUsageValue\r
- again with a different report packet\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
- collection combination does not exist\r
- in any reports for this ReportType\r
---*/\r
-\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetScaledUsageValue (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN USAGE Usage,\r
- OUT PLONG UsageValue,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-\r
-/*++\r
-Description\r
- HidP_GetScaledUsageValue retrieves a UsageValue from the HID report packet\r
- in the field corresponding to the given usage page and usage. If a report\r
- packet contains two different fields with the same Usage and UsagePage,\r
- they can be distinguished with the optional LinkCollection field value.\r
-\r
- If the specified field has a defined physical range, this function converts\r
- the logical value that exists in the report packet to the corresponding\r
- physical value. If a physical range does not exist, the function will\r
- return the logical value. This function will check to verify that the\r
- logical value in the report falls within the declared logical range.\r
-\r
- When doing the conversion between logical and physical values, this\r
- function assumes a linear extrapolation between the physical max/min and\r
- the logical max/min. (Where logical is the values reported by the device\r
- and physical is the value returned by this function). If the data field\r
- size is less than 32 bits, then HidP_GetScaledUsageValue will sign extend\r
- the value to 32 bits.\r
-\r
- If the range checking fails but the field has NULL values, the function\r
- will set UsageValue to 0 and return HIDP_STATUS_NULL. Otherwise, it\r
- returns a HIDP_STATUS_OUT_OF_RANGE error.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Output or HidP_Feature.\r
-\r
- UsagePage The usage page to which the given usage refers.\r
-\r
- LinkCollection (Optional) This value can be used to differentiate\r
- between two fields that may have the same\r
- UsagePage and Usage but exist in different\r
- collections. If the link collection value\r
- is zero, this function will retrieve the first\r
- field it finds that matches the usage page\r
- and usage.\r
-\r
- Usage The usage whose value HidP_GetScaledUsageValue will retrieve\r
-\r
- UsageValue The value retrieved from the report buffer. See the routine\r
- description above for the different interpretations of this\r
- value\r
-\r
- PreparsedData The preparsed data returned from HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length (in bytes) of the given report packet.\r
-\r
-\r
-Return Value:\r
- HidP_GetScaledUsageValue returns the following error codes:\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successfully retrieving the value\r
- from the report packet\r
-· HIDP_STATUS_NULL -- if the report packet had a NULL value\r
- set\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_VALUE_OUT_OF_RANGE -- if the value retrieved from the packet\r
- falls outside the logical range and\r
- the field does not support NULL values\r
-· HIDP_STATUS_BAD_LOG_PHY_VALUES -- if the field has a physical range but\r
- either the logical range is invalid\r
- (max <= min) or the physical range is\r
- invalid\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
- link collection exist but exists in\r
- a report with a different report ID\r
- than the report being passed in. To\r
- set this value, call\r
- HidP_GetScaledUsageValue with a\r
- different report packet\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
- collection combination does not exist\r
- in any reports for this ReportType\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_GetUsageValueArray (\r
- IN HIDP_REPORT_TYPE ReportType,\r
- IN USAGE UsagePage,\r
- IN USHORT LinkCollection, // Optional\r
- IN USAGE Usage,\r
- OUT PCHAR UsageValue,\r
- IN USHORT UsageValueByteLength,\r
- IN PHIDP_PREPARSED_DATA PreparsedData,\r
- IN PCHAR Report,\r
- IN ULONG ReportLength\r
- );\r
-\r
-/*++\r
-Routine Descripton:\r
- A usage value array occurs when the last usage in the list of usages\r
- describing a main item must be repeated because there are less usages defined\r
- than there are report counts declared for the given main item. In this case\r
- a single value cap is allocated for that usage and the report count of that\r
- value cap is set to reflect the number of fields to which that usage refers.\r
-\r
- HidP_GetUsageValueArray returns the raw bits for that usage which spans\r
- more than one field in a report.\r
-\r
- NOTE: This function currently does not support value arrays where the\r
- ReportSize for each of the fields in the array is not a multiple\r
- of 8 bits.\r
-\r
- The UsageValue buffer will have the raw values as they are set\r
- in the report packet.\r
-\r
-Parameters:\r
-\r
- ReportType One of HidP_Input, HidP_Output or HidP_Feature.\r
-\r
- UsagePage The usage page to which the given usage refers.\r
-\r
- LinkCollection (Optional) This value can be used to differentiate\r
- between two fields that may have the same\r
- UsagePage and Usage but exist in different\r
- collections. If the link collection value\r
- is zero, this function will set the first field\r
- it finds that matches the usage page and\r
- usage.\r
-\r
- Usage The usage whose value HidP_GetUsageValueArray will retreive.\r
-\r
- UsageValue A pointer to an array of characters where the value will be\r
- placed. The number of BITS required is found by multiplying the\r
- BitSize and ReportCount fields of the Value Cap for this\r
- control. The least significant bit of this control found in the\r
- given report will be placed in the least significant bit location\r
- of the buffer (little-endian format), regardless of whether\r
- or not the field is byte aligned or if the BitSize is a multiple\r
- of sizeof (CHAR).\r
-\r
- See note above about current implementation limitations\r
-\r
- UsageValueByteLength\r
- the length of the given UsageValue buffer.\r
-\r
- PreparsedData The preparsed data returned by the HIDCLASS\r
-\r
- Report The report packet.\r
-\r
- ReportLength Length of the given report packet.\r
-\r
-Return Value:\r
-\r
-· HIDP_STATUS_SUCCESS -- upon successfully retrieving the value\r
- from the report packet\r
-· HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid.\r
-· HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid\r
-· HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not\r
- equal to the length specified in\r
- the HIDP_CAPS structure for the given\r
- ReportType\r
-· HIDP_STATUS_NOT_VALUE_ARRAY -- if the control specified is not a\r
- value array -- a value array will have\r
- a ReportCount field in the\r
- HIDP_VALUE_CAPS structure that is > 1\r
- Use HidP_GetUsageValue instead\r
-· HIDP_STATUS_BUFFER_TOO_SMALL -- if the size of the passed in buffer in\r
- which to return the array is too small\r
- (ie. has fewer values than the number of\r
- fields in the array\r
-· HIDP_STATUS_NOT_IMPLEMENTED -- if the usage value array has field sizes\r
- that are not multiples of 8 bits, this\r
- error code is returned since the function\r
- currently does not handle getting values\r
- from such arrays.\r
-· HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and\r
- link collection exist but exists in\r
- a report with a different report ID\r
- than the report being passed in. To\r
- set this value, call\r
- HidP_GetUsageValueArray with a\r
- different report packet\r
-· HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link\r
- collection combination does not exist\r
- in any reports for this ReportType\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_UsageListDifference (\r
- IN PUSAGE PreviousUsageList,\r
- IN PUSAGE CurrentUsageList,\r
- OUT PUSAGE BreakUsageList,\r
- OUT PUSAGE MakeUsageList,\r
- IN ULONG UsageListLength\r
- );\r
-/*++\r
-Routine Description:\r
- This function will return the difference between a two lists of usages\r
- (as might be returned from HidP_GetUsages), In other words, it will return\r
- return a list of usages that are in the current list but not the previous\r
- list as well as a list of usages that are in the previous list but not\r
- the current list.\r
-\r
-Parameters:\r
-\r
- PreviousUsageList The list of usages before.\r
- CurrentUsageList The list of usages now.\r
- BreakUsageList Previous - Current.\r
- MakeUsageList Current - Previous.\r
- UsageListLength Represents the length of the usage lists in array\r
- elements. If comparing two lists with a differing\r
- number of array elements, this value should be\r
- the size of the larger of the two lists. Any\r
- zero found with a list indicates an early termination\r
- of the list and any usages found after the first zero\r
- will be ignored.\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_UsageAndPageListDifference (\r
- IN PUSAGE_AND_PAGE PreviousUsageList,\r
- IN PUSAGE_AND_PAGE CurrentUsageList,\r
- OUT PUSAGE_AND_PAGE BreakUsageList,\r
- OUT PUSAGE_AND_PAGE MakeUsageList,\r
- IN ULONG UsageListLength\r
- );\r
-\r
-//\r
-// Produce Make or Break Codes\r
-//\r
-typedef enum _HIDP_KEYBOARD_DIRECTION {\r
- HidP_Keyboard_Break,\r
- HidP_Keyboard_Make\r
-} HIDP_KEYBOARD_DIRECTION;\r
-\r
-//\r
-// A bitmap of the current shift state of the keyboard when using the\r
-// below keyboard usages to i8042 translation function.\r
-//\r
-typedef struct _HIDP_KEYBOARD_MODIFIER_STATE {\r
- union {\r
- struct {\r
- ULONG LeftControl: 1;\r
- ULONG LeftShift: 1;\r
- ULONG LeftAlt: 1;\r
- ULONG LeftGUI: 1;\r
- ULONG RightControl: 1;\r
- ULONG RightShift: 1;\r
- ULONG RightAlt: 1;\r
- ULONG RigthGUI: 1;\r
- ULONG CapsLock: 1;\r
- ULONG ScollLock: 1;\r
- ULONG NumLock: 1;\r
- ULONG Reserved: 21;\r
- };\r
- ULONG ul;\r
- };\r
-\r
-} HIDP_KEYBOARD_MODIFIER_STATE, * PHIDP_KEYBOARD_MODIFIER_STATE;\r
-\r
-//\r
-// A call back function to give the i8042 scan codes to the caller of\r
-// the below translation function.\r
-//\r
-typedef BOOLEAN (* PHIDP_INSERT_SCANCODES) (\r
- IN PVOID Context, // Some caller supplied context.\r
- IN PCHAR NewScanCodes, // A list of i8042 scan codes.\r
- IN ULONG Length // the length of the scan codes.\r
- );\r
-\r
-NTSTATUS __stdcall\r
-HidP_TranslateUsageAndPagesToI8042ScanCodes (\r
- IN PUSAGE_AND_PAGE ChangedUsageList,\r
- IN ULONG UsageListLength,\r
- IN HIDP_KEYBOARD_DIRECTION KeyAction,\r
- IN OUT PHIDP_KEYBOARD_MODIFIER_STATE ModifierState,\r
- IN PHIDP_INSERT_SCANCODES InsertCodesProcedure,\r
- IN PVOID InsertCodesContext\r
- );\r
-/*++\r
-Routine Description:\r
-Parameters:\r
---*/\r
-\r
-NTSTATUS __stdcall\r
-HidP_TranslateUsagesToI8042ScanCodes (\r
- IN PUSAGE ChangedUsageList,\r
- IN ULONG UsageListLength,\r
- IN HIDP_KEYBOARD_DIRECTION KeyAction,\r
- IN OUT PHIDP_KEYBOARD_MODIFIER_STATE ModifierState,\r
- IN PHIDP_INSERT_SCANCODES InsertCodesProcedure,\r
- IN PVOID InsertCodesContext\r
- );\r
-/*++\r
-Routine Description:\r
-Parameters:\r
---*/\r
-\r
-\r
-\r
-//\r
-// Define NT Status codes with Facility Code of FACILITY_HID_ERROR_CODE\r
-//\r
-\r
-// FACILITY_HID_ERROR_CODE defined in ntstatus.h\r
-#ifndef FACILITY_HID_ERROR_CODE\r
-#define FACILITY_HID_ERROR_CODE 0x11\r
-#endif\r
-\r
-#define HIDP_ERROR_CODES(SEV, CODE) \\r
- ((NTSTATUS) (((SEV) << 28) | (FACILITY_HID_ERROR_CODE << 16) | (CODE)))\r
-\r
-#define HIDP_STATUS_SUCCESS (HIDP_ERROR_CODES(0x0,0))\r
-#define HIDP_STATUS_NULL (HIDP_ERROR_CODES(0x8,1))\r
-#define HIDP_STATUS_INVALID_PREPARSED_DATA (HIDP_ERROR_CODES(0xC,1))\r
-#define HIDP_STATUS_INVALID_REPORT_TYPE (HIDP_ERROR_CODES(0xC,2))\r
-#define HIDP_STATUS_INVALID_REPORT_LENGTH (HIDP_ERROR_CODES(0xC,3))\r
-#define HIDP_STATUS_USAGE_NOT_FOUND (HIDP_ERROR_CODES(0xC,4))\r
-#define HIDP_STATUS_VALUE_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,5))\r
-#define HIDP_STATUS_BAD_LOG_PHY_VALUES (HIDP_ERROR_CODES(0xC,6))\r
-#define HIDP_STATUS_BUFFER_TOO_SMALL (HIDP_ERROR_CODES(0xC,7))\r
-#define HIDP_STATUS_INTERNAL_ERROR (HIDP_ERROR_CODES(0xC,8))\r
-#define HIDP_STATUS_I8042_TRANS_UNKNOWN (HIDP_ERROR_CODES(0xC,9))\r
-#define HIDP_STATUS_INCOMPATIBLE_REPORT_ID (HIDP_ERROR_CODES(0xC,0xA))\r
-#define HIDP_STATUS_NOT_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xB))\r
-#define HIDP_STATUS_IS_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xC))\r
-#define HIDP_STATUS_DATA_INDEX_NOT_FOUND (HIDP_ERROR_CODES(0xC,0xD))\r
-#define HIDP_STATUS_DATA_INDEX_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,0xE))\r
-#define HIDP_STATUS_BUTTON_NOT_PRESSED (HIDP_ERROR_CODES(0xC,0xF))\r
-#define HIDP_STATUS_REPORT_DOES_NOT_EXIST (HIDP_ERROR_CODES(0xC,0x10))\r
-#define HIDP_STATUS_NOT_IMPLEMENTED (HIDP_ERROR_CODES(0xC,0x20))\r
-\r
-//\r
-// We blundered this status code.\r
-//\r
-#define HIDP_STATUS_I8242_TRANS_UNKNOWN HIDP_STATUS_I8042_TRANS_UNKNOWN\r
-\r
-#include <poppack.h>\r
-\r
-#endif\r
+++ /dev/null
-/*++\r
-\r
-Copyright (c) 1996 Microsoft Corporation\r
-\r
-Module Name:\r
-\r
- HIDSDI.H\r
-\r
-Abstract:\r
-\r
- This module contains the PUBLIC definitions for the\r
- code that implements the HID dll.\r
-\r
-Environment:\r
-\r
- Kernel & user mode\r
-\r
---*/\r
-\r
-\r
-#ifndef _HIDSDI_H\r
-#define _HIDSDI_H\r
-\r
-#include <pshpack4.h>\r
-\r
-//#include "wtypes.h"\r
-\r
-//#include <windef.h>\r
-//#include <win32.h>\r
-//#include <basetyps.h>\r
-\r
-typedef LONG NTSTATUS;\r
-#include "hidusage.h"\r
-#include "hidpi.h"\r
-\r
-typedef struct _HIDD_CONFIGURATION {\r
- PVOID cookie;\r
- ULONG size;\r
- ULONG RingBufferSize;\r
-} HIDD_CONFIGURATION, *PHIDD_CONFIGURATION;\r
-\r
-typedef struct _HIDD_ATTRIBUTES {\r
- ULONG Size; // = sizeof (struct _HIDD_ATTRIBUTES)\r
-\r
- //\r
- // Vendor ids of this hid device\r
- //\r
- USHORT VendorID;\r
- USHORT ProductID;\r
- USHORT VersionNumber;\r
-\r
- //\r
- // Additional fields will be added to the end of this structure.\r
- //\r
-} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;\r
-\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetAttributes (\r
- IN HANDLE HidDeviceObject,\r
- OUT PHIDD_ATTRIBUTES Attributes\r
- );\r
-/*++\r
-Routine Description:\r
- Fill in the given HIDD_ATTRIBUTES structure with the attributes of the\r
- given hid device.\r
-\r
---*/\r
-\r
-\r
-void __stdcall\r
-HidD_GetHidGuid (\r
- OUT LPGUID HidGuid\r
- );\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetPreparsedData (\r
- IN HANDLE HidDeviceObject,\r
- OUT PHIDP_PREPARSED_DATA * PreparsedData\r
- );\r
-/*++\r
-Routine Description:\r
- Given a handle to a valid Hid Class Device Object, retrieve the preparsed\r
- data for the device. This routine will allocate the appropriately \r
- sized buffer to hold this preparsed data. It is up to client to call\r
- HidP_FreePreparsedData to free the memory allocated to this structure when\r
- it is no longer needed.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device that the client obtains using \r
- a call to CreateFile on a valid Hid device string name.\r
- The string name can be obtained using standard PnP calls.\r
-\r
- PreparsedData An opaque data structure used by other functions in this \r
- library to retrieve information about a given device.\r
-\r
-Return Value:\r
- TRUE if successful.\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_FreePreparsedData (\r
- IN PHIDP_PREPARSED_DATA PreparsedData\r
- );\r
-\r
-BOOLEAN __stdcall\r
-HidD_FlushQueue (\r
- IN HANDLE HidDeviceObject\r
- );\r
-/*++\r
-Routine Description:\r
- Flush the input queue for the given HID device.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device that the client obtains using \r
- a call to CreateFile on a valid Hid device string name.\r
- The string name can be obtained using standard PnP calls.\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetConfiguration (\r
- IN HANDLE HidDeviceObject,\r
- OUT PHIDD_CONFIGURATION Configuration,\r
- IN ULONG ConfigurationLength\r
- );\r
-/*++\r
-Routine Description:\r
- Get the configuration information for this Hid device\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
-\r
- Configuration A configuration structure. HidD_GetConfiguration MUST\r
- be called before the configuration can be modified and\r
- set using HidD_SetConfiguration\r
-\r
- ConfigurationLength That is ``sizeof (HIDD_CONFIGURATION)''. Using this\r
- parameter, we can later increase the length of the \r
- configuration array and not break older apps.\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_SetConfiguration (\r
- IN HANDLE HidDeviceObject,\r
- IN PHIDD_CONFIGURATION Configuration,\r
- IN ULONG ConfigurationLength\r
- );\r
-/*++\r
-Routine Description:\r
- Set the configuration information for this Hid device...\r
- \r
- NOTE: HidD_GetConfiguration must be called to retrieve the current \r
- configuration information before this information can be modified \r
- and set.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- Configuration A configuration structure. HidD_GetConfiguration MUST\r
- be called before the configuration can be modified and\r
- set using HidD_SetConfiguration\r
- \r
- ConfigurationLength That is ``sizeof (HIDD_CONFIGURATION)''. Using this\r
- parameter, we can later increase the length of the \r
- configuration array and not break older apps.\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetFeature (\r
- IN HANDLE HidDeviceObject,\r
- OUT PVOID ReportBuffer,\r
- IN ULONG ReportBufferLength\r
- );\r
-/*++\r
-Routine Description:\r
- Retrieve a feature report from a HID device.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- ReportBuffer The buffer that the feature report should be placed \r
- into. The first byte of the buffer should be set to\r
- the report ID of the desired report\r
- \r
- ReportBufferLength The size (in bytes) of ReportBuffer. This value \r
- should be greater than or equal to the \r
- FeatureReportByteLength field as specified in the \r
- HIDP_CAPS structure for the device\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_SetFeature (\r
- IN HANDLE HidDeviceObject,\r
- IN PVOID ReportBuffer,\r
- IN ULONG ReportBufferLength\r
- );\r
-/*++\r
-Routine Description:\r
- Send a feature report to a HID device.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- ReportBuffer The buffer of the feature report to send to the device\r
- \r
- ReportBufferLength The size (in bytes) of ReportBuffer. This value \r
- should be greater than or equal to the \r
- FeatureReportByteLength field as specified in the \r
- HIDP_CAPS structure for the device\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetNumInputBuffers (\r
- IN HANDLE HidDeviceObject,\r
- OUT PULONG NumberBuffers\r
- );\r
-/*++\r
-Routine Description:\r
- This function returns the number of input buffers used by the specified\r
- file handle to the Hid device. Each file object has a number of buffers\r
- associated with it to queue reports read from the device but which have\r
- not yet been read by the user-mode app with a handle to that device.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- NumberBuffers Number of buffers currently being used for this file\r
- handle to the Hid device\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_SetNumInputBuffers (\r
- IN HANDLE HidDeviceObject,\r
- OUT ULONG NumberBuffers\r
- );\r
-/*++\r
-\r
-Routine Description:\r
- This function sets the number of input buffers used by the specified\r
- file handle to the Hid device. Each file object has a number of buffers\r
- associated with it to queue reports read from the device but which have\r
- not yet been read by the user-mode app with a handle to that device.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- NumberBuffers New number of buffers to use for this file handle to\r
- the Hid device\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetPhysicalDescriptor (\r
- IN HANDLE HidDeviceObject,\r
- OUT PVOID Buffer,\r
- IN ULONG BufferLength\r
- );\r
-/*++\r
-Routine Description:\r
- This function retrieves the raw physical descriptor for the specified\r
- Hid device. \r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- Buffer Buffer which on return will contain the physical\r
- descriptor if one exists for the specified device\r
- handle\r
-\r
- BufferLength Length of buffer (in bytes)\r
-\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetManufacturerString (\r
- IN HANDLE HidDeviceObject,\r
- OUT PVOID Buffer,\r
- IN ULONG BufferLength\r
- );\r
-/*++\r
-Routine Description:\r
- This function retrieves the manufacturer string from the specified \r
- Hid device. \r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- Buffer Buffer which on return will contain the manufacturer\r
- string returned from the device. This string is a \r
- wide-character string\r
-\r
- BufferLength Length of Buffer (in bytes)\r
-\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetProductString (\r
- IN HANDLE HidDeviceObject,\r
- OUT PVOID Buffer,\r
- IN ULONG BufferLength\r
- );\r
-/*++\r
-Routine Description:\r
- This function retrieves the product string from the specified \r
- Hid device. \r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- Buffer Buffer which on return will contain the product\r
- string returned from the device. This string is a \r
- wide-character string\r
-\r
- BufferLength Length of Buffer (in bytes)\r
-\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetIndexedString (\r
- IN HANDLE HidDeviceObject,\r
- IN ULONG StringIndex,\r
- OUT PVOID Buffer,\r
- IN ULONG BufferLength\r
- );\r
-/*++\r
-Routine Description:\r
- This function retrieves a string from the specified Hid device that is\r
- specified with a certain string index.\r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- StringIndex Index of the string to retrieve\r
-\r
- Buffer Buffer which on return will contain the product\r
- string returned from the device. This string is a \r
- wide-character string\r
-\r
- BufferLength Length of Buffer (in bytes)\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-BOOLEAN __stdcall\r
-HidD_GetSerialNumberString (\r
- IN HANDLE HidDeviceObject,\r
- OUT PVOID Buffer,\r
- IN ULONG BufferLength\r
- );\r
-/*++\r
-Routine Description:\r
- This function retrieves the serial number string from the specified \r
- Hid device. \r
-\r
-Arguments:\r
- HidDeviceObject A handle to a Hid Device Object.\r
- \r
- Buffer Buffer which on return will contain the serial number\r
- string returned from the device. This string is a \r
- wide-character string\r
-\r
- BufferLength Length of Buffer (in bytes)\r
-\r
-Return Value:\r
- TRUE if successful\r
- FALSE otherwise -- Use GetLastError() to get extended error information\r
---*/\r
-\r
-\r
-#include <poppack.h>\r
-\r
-#endif\r
+++ /dev/null
-/*++\r
-\r
-Copyright (c) 1996, 1997 Microsoft Corporation\r
-\r
-Module Name:\r
-\r
- HIDUSAGE.H\r
-\r
-Abstract:\r
-\r
- Public Definitions of HID USAGES.\r
-\r
-Environment:\r
-\r
- Kernel & user mode\r
-\r
---*/\r
-\r
-#ifndef __HIDUSAGE_H__\r
-#define __HIDUSAGE_H__\r
-\r
-//\r
-// Usage Pages\r
-//\r
-\r
-typedef USHORT USAGE, *PUSAGE;\r
-\r
-#define HID_USAGE_PAGE_GENERIC ((USAGE) 0x01)\r
-#define HID_USAGE_PAGE_SIMULATION ((USAGE) 0x02)\r
-#define HID_USAGE_PAGE_VR ((USAGE) 0x03)\r
-#define HID_USAGE_PAGE_SPORT ((USAGE) 0x04)\r
-#define HID_USAGE_PAGE_GAME ((USAGE) 0x05)\r
-#define HID_USAGE_PAGE_KEYBOARD ((USAGE) 0x07)\r
-#define HID_USAGE_PAGE_LED ((USAGE) 0x08)\r
-#define HID_USAGE_PAGE_BUTTON ((USAGE) 0x09)\r
-#define HID_USAGE_PAGE_ORDINAL ((USAGE) 0x0A)\r
-#define HID_USAGE_PAGE_TELEPHONY ((USAGE) 0x0B)\r
-#define HID_USAGE_PAGE_CONSUMER ((USAGE) 0x0C)\r
-#define HID_USAGE_PAGE_DIGITIZER ((USAGE) 0x0D)\r
-#define HID_USAGE_PAGE_UNICODE ((USAGE) 0x10)\r
-#define HID_USAGE_PAGE_ALPHANUMERIC ((USAGE) 0x14)\r
-\r
-\r
-//\r
-// Usages from Generic Desktop Page (0x01)\r
-//\r
-\r
-#define HID_USAGE_GENERIC_POINTER ((USAGE) 0x01)\r
-#define HID_USAGE_GENERIC_MOUSE ((USAGE) 0x02)\r
-#define HID_USAGE_GENERIC_JOYSTICK ((USAGE) 0x04)\r
-#define HID_USAGE_GENERIC_GAMEPAD ((USAGE) 0x05)\r
-#define HID_USAGE_GENERIC_KEYBOARD ((USAGE) 0x06)\r
-#define HID_USAGE_GENERIC_KEYPAD ((USAGE) 0x07)\r
-#define HID_USAGE_GENERIC_SYSTEM_CTL ((USAGE) 0x80)\r
-\r
-#define HID_USAGE_GENERIC_X ((USAGE) 0x30)\r
-#define HID_USAGE_GENERIC_Y ((USAGE) 0x31)\r
-#define HID_USAGE_GENERIC_Z ((USAGE) 0x32)\r
-#define HID_USAGE_GENERIC_RX ((USAGE) 0x33)\r
-#define HID_USAGE_GENERIC_RY ((USAGE) 0x34)\r
-#define HID_USAGE_GENERIC_RZ ((USAGE) 0x35)\r
-#define HID_USAGE_GENERIC_SLIDER ((USAGE) 0x36)\r
-#define HID_USAGE_GENERIC_DIAL ((USAGE) 0x37)\r
-#define HID_USAGE_GENERIC_WHEEL ((USAGE) 0x38)\r
-#define HID_USAGE_GENERIC_HATSWITCH ((USAGE) 0x39)\r
-#define HID_USAGE_GENERIC_COUNTED_BUFFER ((USAGE) 0x3A)\r
-#define HID_USAGE_GENERIC_BYTE_COUNT ((USAGE) 0x3B)\r
-#define HID_USAGE_GENERIC_MOTION_WAKEUP ((USAGE) 0x3C)\r
-#define HID_USAGE_GENERIC_VX ((USAGE) 0x40)\r
-#define HID_USAGE_GENERIC_VY ((USAGE) 0x41)\r
-#define HID_USAGE_GENERIC_VZ ((USAGE) 0x42)\r
-#define HID_USAGE_GENERIC_VBRX ((USAGE) 0x43)\r
-#define HID_USAGE_GENERIC_VBRY ((USAGE) 0x44)\r
-#define HID_USAGE_GENERIC_VBRZ ((USAGE) 0x45)\r
-#define HID_USAGE_GENERIC_VNO ((USAGE) 0x46)\r
-#define HID_USAGE_GENERIC_SYSCTL_POWER ((USAGE) 0x81)\r
-#define HID_USAGE_GENERIC_SYSCTL_SLEEP ((USAGE) 0x82)\r
-#define HID_USAGE_GENERIC_SYSCTL_WAKE ((USAGE) 0x83)\r
-#define HID_USAGE_GENERIC_SYSCTL_CONTEXT_MENU ((USAGE) 0x84)\r
-#define HID_USAGE_GENERIC_SYSCTL_MAIN_MENU ((USAGE) 0x85)\r
-#define HID_USAGE_GENERIC_SYSCTL_APP_MENU ((USAGE) 0x86)\r
-#define HID_USAGE_GENERIC_SYSCTL_HELP_MENU ((USAGE) 0x87)\r
-#define HID_USAGE_GENERIC_SYSCTL_MENU_EXIT ((USAGE) 0x88)\r
-#define HID_USAGE_GENERIC_SYSCTL_MENU_SELECT ((USAGE) 0x89)\r
-#define HID_USAGE_GENERIC_SYSCTL_MENU_RIGHT ((USAGE) 0x8A)\r
-#define HID_USAGE_GENERIC_SYSCTL_MENU_LEFT ((USAGE) 0x8B)\r
-#define HID_USAGE_GENERIC_SYSCTL_MENU_UP ((USAGE) 0x8C)\r
-#define HID_USAGE_GENERIC_SYSCTL_MENU_DOWN ((USAGE) 0x8D)\r
-\r
-//\r
-// Usages from Simulation Controls Page (0x02)\r
-//\r
-\r
-#define HID_USAGE_SIMULATION_RUDDER ((USAGE) 0xBA)\r
-#define HID_USAGE_SIMULATION_THROTTLE ((USAGE) 0xBB)\r
-\r
-//\r
-// Virtual Reality Controls Page (0x03)\r
-//\r
-\r
-\r
-//\r
-// Sport Controls Page (0x04)\r
-//\r
-\r
-\r
-//\r
-// Game Controls Page (0x05)\r
-//\r
-\r
-\r
-//\r
-// Keyboard/Keypad Page (0x07)\r
-//\r
-\r
- // Error "keys"\r
-#define HID_USAGE_KEYBOARD_NOEVENT ((USAGE) 0x00)\r
-#define HID_USAGE_KEYBOARD_ROLLOVER ((USAGE) 0x01)\r
-#define HID_USAGE_KEYBOARD_POSTFAIL ((USAGE) 0x02)\r
-#define HID_USAGE_KEYBOARD_UNDEFINED ((USAGE) 0x03)\r
-\r
- // Letters\r
-#define HID_USAGE_KEYBOARD_aA ((USAGE) 0x04)\r
-#define HID_USAGE_KEYBOARD_zZ ((USAGE) 0x1D)\r
- // Numbers\r
-#define HID_USAGE_KEYBOARD_ONE ((USAGE) 0x1E)\r
-#define HID_USAGE_KEYBOARD_ZERO ((USAGE) 0x27)\r
- // Modifier Keys\r
-#define HID_USAGE_KEYBOARD_LCTRL ((USAGE) 0xE0)\r
-#define HID_USAGE_KEYBOARD_LSHFT ((USAGE) 0xE1)\r
-#define HID_USAGE_KEYBOARD_LALT ((USAGE) 0xE2)\r
-#define HID_USAGE_KEYBOARD_LGUI ((USAGE) 0xE3)\r
-#define HID_USAGE_KEYBOARD_RCTRL ((USAGE) 0xE4)\r
-#define HID_USAGE_KEYBOARD_RSHFT ((USAGE) 0xE5)\r
-#define HID_USAGE_KEYBOARD_RALT ((USAGE) 0xE6)\r
-#define HID_USAGE_KEYBOARD_RGUI ((USAGE) 0xE7)\r
-#define HID_USAGE_KEYBOARD_SCROLL_LOCK ((USAGE) 0x47)\r
-#define HID_USAGE_KEYBOARD_NUM_LOCK ((USAGE) 0x53)\r
-#define HID_USAGE_KEYBOARD_CAPS_LOCK ((USAGE) 0x39)\r
- // Funtion keys\r
-#define HID_USAGE_KEYBOARD_F1 ((USAGE) 0x3A)\r
-#define HID_USAGE_KEYBOARD_F12 ((USAGE) 0x45)\r
-\r
-#define HID_USAGE_KEYBOARD_RETURN ((USAGE) 0x28)\r
-#define HID_USAGE_KEYBOARD_ESCAPE ((USAGE) 0x29)\r
-#define HID_USAGE_KEYBOARD_DELETE ((USAGE) 0x2A)\r
-\r
-#define HID_USAGE_KEYBOARD_PRINT_SCREEN ((USAGE) 0x46)\r
-\r
-// and hundreds more...\r
-\r
-//\r
-// LED Page (0x08)\r
-//\r
-\r
-#define HID_USAGE_LED_NUM_LOCK ((USAGE) 0x01)\r
-#define HID_USAGE_LED_CAPS_LOCK ((USAGE) 0x02)\r
-#define HID_USAGE_LED_SCROLL_LOCK ((USAGE) 0x03)\r
-#define HID_USAGE_LED_COMPOSE ((USAGE) 0x04)\r
-#define HID_USAGE_LED_KANA ((USAGE) 0x05)\r
-#define HID_USAGE_LED_POWER ((USAGE) 0x06)\r
-#define HID_USAGE_LED_SHIFT ((USAGE) 0x07)\r
-#define HID_USAGE_LED_DO_NOT_DISTURB ((USAGE) 0x08)\r
-#define HID_USAGE_LED_MUTE ((USAGE) 0x09)\r
-#define HID_USAGE_LED_TONE_ENABLE ((USAGE) 0x0A)\r
-#define HID_USAGE_LED_HIGH_CUT_FILTER ((USAGE) 0x0B)\r
-#define HID_USAGE_LED_LOW_CUT_FILTER ((USAGE) 0x0C)\r
-#define HID_USAGE_LED_EQUALIZER_ENABLE ((USAGE) 0x0D)\r
-#define HID_USAGE_LED_SOUND_FIELD_ON ((USAGE) 0x0E)\r
-#define HID_USAGE_LED_SURROUND_FIELD_ON ((USAGE) 0x0F)\r
-#define HID_USAGE_LED_REPEAT ((USAGE) 0x10)\r
-#define HID_USAGE_LED_STEREO ((USAGE) 0x11)\r
-#define HID_USAGE_LED_SAMPLING_RATE_DETECT ((USAGE) 0x12)\r
-#define HID_USAGE_LED_SPINNING ((USAGE) 0x13)\r
-#define HID_USAGE_LED_CAV ((USAGE) 0x14)\r
-#define HID_USAGE_LED_CLV ((USAGE) 0x15)\r
-#define HID_USAGE_LED_RECORDING_FORMAT_DET ((USAGE) 0x16)\r
-#define HID_USAGE_LED_OFF_HOOK ((USAGE) 0x17)\r
-#define HID_USAGE_LED_RING ((USAGE) 0x18)\r
-#define HID_USAGE_LED_MESSAGE_WAITING ((USAGE) 0x19)\r
-#define HID_USAGE_LED_DATA_MODE ((USAGE) 0x1A)\r
-#define HID_USAGE_LED_BATTERY_OPERATION ((USAGE) 0x1B)\r
-#define HID_USAGE_LED_BATTERY_OK ((USAGE) 0x1C)\r
-#define HID_USAGE_LED_BATTERY_LOW ((USAGE) 0x1D)\r
-#define HID_USAGE_LED_SPEAKER ((USAGE) 0x1E)\r
-#define HID_USAGE_LED_HEAD_SET ((USAGE) 0x1F)\r
-#define HID_USAGE_LED_HOLD ((USAGE) 0x20)\r
-#define HID_USAGE_LED_MICROPHONE ((USAGE) 0x21)\r
-#define HID_USAGE_LED_COVERAGE ((USAGE) 0x22)\r
-#define HID_USAGE_LED_NIGHT_MODE ((USAGE) 0x23)\r
-#define HID_USAGE_LED_SEND_CALLS ((USAGE) 0x24)\r
-#define HID_USAGE_LED_CALL_PICKUP ((USAGE) 0x25)\r
-#define HID_USAGE_LED_CONFERENCE ((USAGE) 0x26)\r
-#define HID_USAGE_LED_STAND_BY ((USAGE) 0x27)\r
-#define HID_USAGE_LED_CAMERA_ON ((USAGE) 0x28)\r
-#define HID_USAGE_LED_CAMERA_OFF ((USAGE) 0x29)\r
-#define HID_USAGE_LED_ON_LINE ((USAGE) 0x2A)\r
-#define HID_USAGE_LED_OFF_LINE ((USAGE) 0x2B)\r
-#define HID_USAGE_LED_BUSY ((USAGE) 0x2C)\r
-#define HID_USAGE_LED_READY ((USAGE) 0x2D)\r
-#define HID_USAGE_LED_PAPER_OUT ((USAGE) 0x2E)\r
-#define HID_USAGE_LED_PAPER_JAM ((USAGE) 0x2F)\r
-#define HID_USAGE_LED_REMOTE ((USAGE) 0x30)\r
-#define HID_USAGE_LED_FORWARD ((USAGE) 0x31)\r
-#define HID_USAGE_LED_REVERSE ((USAGE) 0x32)\r
-#define HID_USAGE_LED_STOP ((USAGE) 0x33)\r
-#define HID_USAGE_LED_REWIND ((USAGE) 0x34)\r
-#define HID_USAGE_LED_FAST_FORWARD ((USAGE) 0x35)\r
-#define HID_USAGE_LED_PLAY ((USAGE) 0x36)\r
-#define HID_USAGE_LED_PAUSE ((USAGE) 0x37)\r
-#define HID_USAGE_LED_RECORD ((USAGE) 0x38)\r
-#define HID_USAGE_LED_ERROR ((USAGE) 0x39)\r
-#define HID_USAGE_LED_SELECTED_INDICATOR ((USAGE) 0x3A)\r
-#define HID_USAGE_LED_IN_USE_INDICATOR ((USAGE) 0x3B)\r
-#define HID_USAGE_LED_MULTI_MODE_INDICATOR ((USAGE) 0x3C)\r
-#define HID_USAGE_LED_INDICATOR_ON ((USAGE) 0x3D)\r
-#define HID_USAGE_LED_INDICATOR_FLASH ((USAGE) 0x3E)\r
-#define HID_USAGE_LED_INDICATOR_SLOW_BLINK ((USAGE) 0x3F)\r
-#define HID_USAGE_LED_INDICATOR_FAST_BLINK ((USAGE) 0x40)\r
-#define HID_USAGE_LED_INDICATOR_OFF ((USAGE) 0x41)\r
-#define HID_USAGE_LED_FLASH_ON_TIME ((USAGE) 0x42)\r
-#define HID_USAGE_LED_SLOW_BLINK_ON_TIME ((USAGE) 0x43)\r
-#define HID_USAGE_LED_SLOW_BLINK_OFF_TIME ((USAGE) 0x44)\r
-#define HID_USAGE_LED_FAST_BLINK_ON_TIME ((USAGE) 0x45)\r
-#define HID_USAGE_LED_FAST_BLINK_OFF_TIME ((USAGE) 0x46)\r
-#define HID_USAGE_LED_INDICATOR_COLOR ((USAGE) 0x47)\r
-#define HID_USAGE_LED_RED ((USAGE) 0x48)\r
-#define HID_USAGE_LED_GREEN ((USAGE) 0x49)\r
-#define HID_USAGE_LED_AMBER ((USAGE) 0x4A)\r
-#define HID_USAGE_LED_GENERIC_INDICATOR ((USAGE) 0x3B)\r
-\r
-//\r
-// Button Page (0x09)\r
-//\r
-// There is no need to label these usages.\r
-//\r
-\r
-\r
-//\r
-// Ordinal Page (0x0A)\r
-//\r
-// There is no need to label these usages.\r
-//\r
-\r
-\r
-//\r
-// Telephony Device Page (0x0B)\r
-//\r
-\r
-#define HID_USAGE_TELEPHONY_PHONE ((USAGE) 0x01)\r
-#define HID_USAGE_TELEPHONY_ANSWERING_MACHINE ((USAGE) 0x02)\r
-#define HID_USAGE_TELEPHONY_MESSAGE_CONTROLS ((USAGE) 0x03)\r
-#define HID_USAGE_TELEPHONY_HANDSET ((USAGE) 0x04)\r
-#define HID_USAGE_TELEPHONY_HEADSET ((USAGE) 0x05)\r
-#define HID_USAGE_TELEPHONY_KEYPAD ((USAGE) 0x06)\r
-#define HID_USAGE_TELEPHONY_PROGRAMMABLE_BUTTON ((USAGE) 0x07)\r
-\r
-//\r
-// and others...\r
-//\r
-\r
-\r
-#endif\r
+++ /dev/null
-#include <windows.h>\r
-#include <setupapi.h>\r
-#include <stdio.h>\r
-#include <ctype.h>\r
-#include <stdlib.h>\r
-extern "C" {\r
-#include "include/hidsdi.h"\r
-#include "include/hidpi.h"\r
-}\r
-\r
-#include "prox.h"\r
-\r
-#define OUR_VID 0x9ac4\r
-#define OUR_PID 0x4b8f\r
-#define bzero(b,len) (memset((b), '\0', (len)), (void) 0)\r
-\r
-int offline = 0;\r
-HANDLE UsbHandle;\r
-\r
-static void ShowError(void)\r
-{\r
- char buf[1024];\r
- FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,\r
- buf, sizeof(buf), NULL);\r
- printf("ERROR: %s", buf);\r
-}\r
-\r
-static BOOL UsbConnect(void)\r
-{\r
- typedef void (__stdcall *GetGuidProc)(GUID *);\r
- typedef BOOLEAN (__stdcall *GetAttrProc)(HANDLE, HIDD_ATTRIBUTES *);\r
- typedef BOOLEAN (__stdcall *GetPreparsedProc)(HANDLE,\r
- PHIDP_PREPARSED_DATA *);\r
- typedef NTSTATUS (__stdcall *GetCapsProc)(PHIDP_PREPARSED_DATA, PHIDP_CAPS);\r
- GetGuidProc getGuid;\r
- GetAttrProc getAttr;\r
- GetPreparsedProc getPreparsed;\r
- GetCapsProc getCaps;\r
-\r
- HMODULE h = LoadLibrary("hid.dll");\r
- getGuid = (GetGuidProc)GetProcAddress(h, "HidD_GetHidGuid");\r
- getAttr = (GetAttrProc)GetProcAddress(h, "HidD_GetAttributes");\r
- getPreparsed = (GetPreparsedProc)GetProcAddress(h, "HidD_GetPreparsedData");\r
- getCaps = (GetCapsProc)GetProcAddress(h, "HidP_GetCaps");\r
-\r
- GUID hidGuid;\r
- getGuid(&hidGuid);\r
-\r
- HDEVINFO devInfo;\r
- devInfo = SetupDiGetClassDevs(&hidGuid, NULL, NULL,\r
- DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);\r
-\r
- SP_DEVICE_INTERFACE_DATA devInfoData;\r
- devInfoData.cbSize = sizeof(devInfoData);\r
-\r
- int i;\r
- for(i = 0;; i++) {\r
- if(!SetupDiEnumDeviceInterfaces(devInfo, 0, &hidGuid, i, &devInfoData))\r
- {\r
- if(GetLastError() != ERROR_NO_MORE_ITEMS) {\r
-// printf("SetupDiEnumDeviceInterfaces failed\n");\r
- }\r
-// printf("done list\n");\r
- SetupDiDestroyDeviceInfoList(devInfo);\r
- return FALSE;\r
- }\r
-\r
-// printf("item %d:\n", i);\r
-\r
- DWORD sizeReqd = 0;\r
- if(!SetupDiGetDeviceInterfaceDetail(devInfo, &devInfoData,\r
- NULL, 0, &sizeReqd, NULL))\r
- {\r
- if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) {\r
-// printf("SetupDiGetDeviceInterfaceDetail (0) failed\n");\r
- continue;\r
- }\r
- }\r
-\r
- SP_DEVICE_INTERFACE_DETAIL_DATA *devInfoDetailData =\r
- (SP_DEVICE_INTERFACE_DETAIL_DATA *)malloc(sizeReqd);\r
- devInfoDetailData->cbSize = sizeof(*devInfoDetailData);\r
-\r
- if(!SetupDiGetDeviceInterfaceDetail(devInfo, &devInfoData,\r
- devInfoDetailData, 87, NULL, NULL))\r
- {\r
-// printf("SetupDiGetDeviceInterfaceDetail (1) failed\n");\r
- continue;\r
- }\r
-\r
- char *path = devInfoDetailData->DevicePath;\r
-\r
- UsbHandle = CreateFile(path, /*GENERIC_READ |*/ GENERIC_WRITE,\r
- FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,\r
- FILE_FLAG_OVERLAPPED, NULL);\r
-\r
- if(UsbHandle == INVALID_HANDLE_VALUE) {\r
- ShowError();\r
-// printf("CreateFile failed: for '%s'\n", path);\r
- continue;\r
- }\r
-\r
- HIDD_ATTRIBUTES attr;\r
- attr.Size = sizeof(attr);\r
- if(!getAttr(UsbHandle, &attr)) {\r
- ShowError();\r
-// printf("HidD_GetAttributes failed\n");\r
- continue;\r
- }\r
-\r
-// printf("VID: %04x PID %04x\n", attr.VendorID, attr.ProductID);\r
-\r
- if(attr.VendorID != OUR_VID || attr.ProductID != OUR_PID) {\r
- CloseHandle(UsbHandle);\r
-// printf(" nope, not us\n");\r
- continue;\r
- }\r
-\r
-// printf ("got it!\n");\r
- CloseHandle(UsbHandle);\r
-\r
- UsbHandle = CreateFile(path, GENERIC_READ | GENERIC_WRITE,\r
- FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,\r
- FILE_FLAG_OVERLAPPED, NULL);\r
-\r
- if(UsbHandle == INVALID_HANDLE_VALUE) {\r
- ShowError();\r
-// printf("Error, couldn't open our own handle as desired.\n");\r
- return FALSE;\r
- }\r
-\r
- PHIDP_PREPARSED_DATA pp;\r
- getPreparsed(UsbHandle, &pp);\r
- HIDP_CAPS caps;\r
-\r
- if(getCaps(pp, &caps) != HIDP_STATUS_SUCCESS) {\r
-// printf("getcaps failed\n");\r
- return FALSE;\r
- }\r
-\r
-// printf("input/out report %d/%d\n", caps.InputReportByteLength,\r
-// caps.OutputReportByteLength);\r
-\r
-\r
- return TRUE;\r
- }\r
- return FALSE;\r
-}\r
-\r
-BOOL ReceiveCommandPoll(UsbCommand *c)\r
-{\r
- static BOOL ReadInProgress = FALSE;\r
- static OVERLAPPED Ov;\r
- static BYTE Buf[65];\r
- static DWORD HaveRead;\r
-\r
- if(!ReadInProgress) {\r
- memset(&Ov, 0, sizeof(Ov));\r
- ReadFile(UsbHandle, Buf, 65, &HaveRead, &Ov);\r
- if(GetLastError() != ERROR_IO_PENDING) {\r
- ShowError();\r
- exit(-1);\r
- }\r
- ReadInProgress = TRUE;\r
- }\r
-\r
- if(HasOverlappedIoCompleted(&Ov)) {\r
- ReadInProgress = FALSE;\r
-\r
- if(!GetOverlappedResult(UsbHandle, &Ov, &HaveRead, FALSE)) {\r
- ShowError();\r
- exit(-1);\r
- }\r
-\r
- memcpy(c, Buf+1, 64);\r
-\r
- return TRUE;\r
- } else {\r
- return FALSE;\r
- }\r
-}\r
-\r
-void ReceiveCommand(UsbCommand *c)\r
-{\r
- while(!ReceiveCommandPoll(c)) {\r
- Sleep(0);\r
- }\r
-}\r
-\r
-void SendCommand(UsbCommand *c, BOOL wantAck)\r
-{\r
- BYTE buf[65];\r
- buf[0] = 0;\r
- memcpy(buf+1, c, 64);\r
-\r
- DWORD written;\r
- OVERLAPPED ov;\r
-\r
- memset(&ov, 0, sizeof(ov));\r
- WriteFile(UsbHandle, buf, 65, &written, &ov);\r
- if(GetLastError() != ERROR_IO_PENDING) {\r
- ShowError();\r
- exit(-1);\r
- }\r
-\r
- while(!HasOverlappedIoCompleted(&ov)) {\r
- Sleep(0);\r
- }\r
-\r
- if(!GetOverlappedResult(UsbHandle, &ov, &written, FALSE)) {\r
- ShowError();\r
- exit(-1);\r
- }\r
-\r
- if(wantAck) {\r
- UsbCommand ack;\r
- ReceiveCommand(&ack);\r
- if(ack.cmd != CMD_ACK) {\r
- printf("bad ACK\n");\r
- exit(-1);\r
- }\r
- }\r
-}\r
-\r
-static DWORD ExpectedAddr;\r
-static BYTE QueuedToSend[256];\r
-static BOOL AllWritten;\r
-#define PHYSICAL_FLASH_START 0x100000\r
-\r
-struct partition {\r
- int start;\r
- int end;\r
- int precious;\r
- const char *name;\r
-};\r
-struct partition partitions[] = {\r
- {0x100000, 0x102000, 1, "bootrom"},\r
- {0x102000, 0x110000, 0, "fpga"},\r
- {0x110000, 0x140000, 0, "os"},\r
-};\r
-\r
-/* If translate is set, subtract PHYSICAL_FLASH_START to translate for old\r
- * bootroms.\r
- */\r
-static void FlushPrevious(int translate)\r
-{\r
- UsbCommand c;\r
- memset(&c, 0, sizeof(c));\r
-\r
-// printf("expected = %08x flush, ", ExpectedAddr);\r
-\r
- int i;\r
- for(i = 0; i < 240; i += 48) {\r
- c.cmd = CMD_SETUP_WRITE;\r
- memcpy(c.d.asBytes, QueuedToSend+i, 48);\r
- c.ext1 = (i/4);\r
- SendCommand(&c, TRUE);\r
- }\r
-\r
- c.cmd = CMD_FINISH_WRITE;\r
- c.ext1 = (ExpectedAddr-1) & (~255);\r
- if(translate) {\r
- c.ext1 -= PHYSICAL_FLASH_START;\r
- }\r
- printf("Flashing address: %08x\r", c.ext1);\r
- memcpy(c.d.asBytes, QueuedToSend+240, 16);\r
- SendCommand(&c, TRUE);\r
-\r
- AllWritten = TRUE;\r
-}\r
-\r
-/* Where must be between start_addr (inclusive) and end_addr (exclusive).\r
- */\r
-static void GotByte(int where, BYTE which, int start_addr, int end_addr, int translate)\r
-{\r
- AllWritten = FALSE;\r
-\r
- if(where < start_addr || where >= end_addr) {\r
- printf("bad: got byte at %08x, outside of range %08x-%08x\n", where, start_addr, end_addr);\r
- exit(-1);\r
- }\r
-\r
- if(where != ExpectedAddr) {\r
- printf("bad: got at %08x, expected at %08x\n", where, ExpectedAddr);\r
- exit(-1);\r
- }\r
- QueuedToSend[where & 255] = which;\r
- ExpectedAddr++;\r
-\r
- if((where & 255) == 255) {\r
- // we have completed a full page\r
- FlushPrevious(translate);\r
- }\r
-}\r
-\r
-static int HexVal(int c)\r
-{\r
- c = tolower(c);\r
- if(c >= '0' && c <= '9') {\r
- return c - '0';\r
- } else if(c >= 'a' && c <= 'f') {\r
- return (c - 'a') + 10;\r
- } else {\r
- printf("bad hex digit '%c'\n", c);\r
- exit(-1);\r
- }\r
-}\r
-\r
-static BYTE HexByte(char *s)\r
-{\r
- return (HexVal(s[0]) << 4) | HexVal(s[1]);\r
-}\r
-\r
-static void LoadFlashFromSRecords(const char *file, int start_addr, int end_addr, int translate)\r
-{\r
- ExpectedAddr = start_addr;\r
-\r
- FILE *f = fopen(file, "r");\r
- if(!f) {\r
- printf("couldn't open file\n");\r
- exit(-1);\r
- }\r
-\r
- char line[512];\r
- while(fgets(line, sizeof(line), f)) {\r
- if(memcmp(line, "S3", 2)==0) {\r
- char *s = line + 2;\r
- int len = HexByte(s) - 5;\r
- s += 2;\r
-\r
- char addrStr[9];\r
- memcpy(addrStr, s, 8);\r
- addrStr[8] = '\0';\r
- DWORD addr;\r
- sscanf(addrStr, "%x", &addr);\r
- s += 8;\r
-\r
- /* Accept files that are located at PHYSICAL_FLASH_START, and files that are located at 0 */\r
- if(addr < PHYSICAL_FLASH_START)\r
- addr += PHYSICAL_FLASH_START;\r
-\r
- int i;\r
- for(i = 0; i < len; i++) {\r
- while((addr+i) > ExpectedAddr) {\r
- GotByte(ExpectedAddr, 0xff, start_addr, end_addr, translate);\r
- }\r
- GotByte(addr+i, HexByte(s), start_addr, end_addr, translate);\r
- s += 2;\r
- }\r
- }\r
- }\r
-\r
- if(!AllWritten) FlushPrevious(translate);\r
-\r
- fclose(f);\r
- printf("\ndone.\n");\r
-}\r
-\r
-static int PrepareFlash(struct partition *p, const char *filename, unsigned int state)\r
-{\r
- int translate = 0;\r
- if(state & DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH) {\r
- UsbCommand c;\r
- c.cmd = CMD_START_FLASH;\r
- c.ext1 = p->start;\r
- c.ext2 = p->end;\r
-\r
- /* Only send magic when flashing bootrom */\r
- if(p->precious) {\r
- c.ext3 = START_FLASH_MAGIC;\r
- } else {\r
- c.ext3 = 0;\r
- }\r
- SendCommand(&c, TRUE);\r
- translate = 0;\r
- } else {\r
- fprintf(stderr, "Warning: Your bootloader does not understand the new START_FLASH command\n");\r
- fprintf(stderr, " It is recommended that you update your bootloader\n\n");\r
- translate = 1;\r
- }\r
-\r
- LoadFlashFromSRecords(filename, p->start, p->end, translate);\r
- return 1;\r
-}\r
-\r
-static unsigned int GetProxmarkState(void)\r
-{\r
- unsigned int state = 0;\r
-\r
- UsbCommand c;\r
- c.cmd = CMD_DEVICE_INFO;\r
- SendCommand(&c, FALSE);\r
-\r
- UsbCommand resp;\r
- ReceiveCommand(&resp);\r
- /* Three cases:\r
- * 1. The old bootrom code will ignore CMD_DEVICE_INFO, but respond with an ACK\r
- * 2. The old os code will respond with CMD_DEBUG_PRINT_STRING and "unknown command"\r
- * 3. The new bootrom and os codes will respond with CMD_DEVICE_INFO and flags\r
- */\r
-\r
- switch(resp.cmd) {\r
- case CMD_ACK:\r
- state = DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM;\r
- break;\r
- case CMD_DEBUG_PRINT_STRING:\r
- state = DEVICE_INFO_FLAG_CURRENT_MODE_OS;\r
- break;\r
- case CMD_DEVICE_INFO:\r
- state = resp.ext1;\r
- break;\r
- default:\r
- fprintf(stderr, "Couldn't get proxmark state, bad response type: 0x%04X\n", resp.cmd);\r
- exit(-1);\r
- break;\r
- }\r
-\r
-#if 0\r
- if(state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) printf("New bootrom present\n");\r
- if(state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) printf("New osimage present\n");\r
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) printf("Currently in bootrom\n");\r
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) printf("Currently in OS\n");\r
-#endif\r
-\r
- return state;\r
-}\r
-\r
-static unsigned int EnterFlashState(void)\r
-{\r
- unsigned int state = GetProxmarkState();\r
-\r
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) {\r
- /* Already in flash state, we're done. */\r
- return state;\r
- }\r
-\r
- if(state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) {\r
- fprintf(stderr,"Entering flash-mode...\n");\r
- UsbCommand c;\r
- bzero(&c, sizeof(c));\r
-\r
- if( (state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) && (state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT) ) {\r
- /* New style handover: Send CMD_START_FLASH, which will reset the board and\r
- * enter the bootrom on the next boot.\r
- */\r
- c.cmd = CMD_START_FLASH;\r
- SendCommand(&c, FALSE);\r
- fprintf(stderr,"(You don't have to do anything. Press and release the button only if you want to abort)\n");\r
- fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");\r
- } else {\r
- /* Old style handover: Ask the user to press the button, then reset the board */\r
- c.cmd = CMD_HARDWARE_RESET;\r
- SendCommand(&c, FALSE);\r
- fprintf(stderr,"(Press and hold down button NOW if your bootloader requires it)\n");\r
- fprintf(stderr,"Waiting for Proxmark to reappear on USB... ");\r
- }\r
-\r
-\r
- Sleep(1000);\r
-\r
- while(!UsbConnect()) { Sleep(1000); }\r
- fprintf(stderr,"Found.\n");\r
-\r
- return GetProxmarkState();\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-static void usage(char **argv)\r
-{\r
- int i;\r
- printf("Usage: %s gui\n", argv[0]);\r
- printf(" %s offline\n", argv[0]);\r
- printf(" %s areas file.s19\n", argv[0]);\r
- printf(" Known areas are:");\r
- for(i=0; i<(sizeof(partitions)/sizeof(partitions[0])); i++) {\r
- fprintf(stderr, " %s", partitions[i].name);\r
- }\r
-\r
- printf("\n");\r
-}\r
-\r
-/* On first call, have *offset = -1, *length = 0; */\r
-static int find_next_area(char *str, int *offset, int *length)\r
-{\r
- if(*str == '\0') return 0;\r
- if((*offset >= 0) && str[*offset + *length] == '\0') return 0;\r
- *offset += 1 + *length;\r
-\r
- char *next_comma = strchr(str + *offset, ',');\r
- if(next_comma == NULL) {\r
- *length = strlen(str) - *offset;\r
- } else {\r
- *length = next_comma-(str+*offset);\r
- }\r
- return 1;\r
-}\r
-\r
-int main(int argc, char **argv)\r
-{\r
- int i = 0;\r
-\r
- if(argc < 2) {\r
- usage(argv);\r
- exit(-1);\r
- }\r
-\r
- // Only do this if NOT in offline mode\r
- if (strcmp(argv[1], "offline"))\r
- {\r
- for(;;) {\r
- if(UsbConnect()) {\r
- break;\r
- }\r
- if(i == 0) {\r
- printf("...no device connected, polling for it now\n");\r
- }\r
- if(i > 50000) {\r
- printf("Could not connect to USB device; exiting.\n");\r
- return -1;\r
- }\r
- i++;\r
- Sleep(5);\r
- }\r
- }\r
-\r
- if(strcmp(argv[1], "gui")==0) {\r
- ShowGui();\r
- } else if(strcmp(argv[1], "offline")==0) {\r
- offline = 1;\r
- ShowGui();\r
- }\r
-\r
- /* Count area arguments */\r
- int areas = 0, offset=-1, length=0;\r
- while(find_next_area(argv[1], &offset, &length)) areas++;\r
-\r
- if(areas != argc - 2) {\r
- usage(argv);\r
- exit(-1);\r
- }\r
-\r
- unsigned int state = EnterFlashState();\r
-\r
- if( !(state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) ) {\r
- fprintf(stderr, "Proxmark would not enter flash state, abort\n");\r
- exit(-1);\r
- }\r
-\r
- offset=-1; length=0;\r
- int current_area = 0;\r
- while(find_next_area(argv[1], &offset, &length)) {\r
- int i;\r
- struct partition *p = NULL;\r
- for(i=0; i<sizeof(partitions)/sizeof(partitions[0]); i++) {\r
- if(strncmp(partitions[i].name, argv[1] + offset, length) == 0) {\r
- /* Check if the name matches the bootrom partition, and if so, require "bootrom" to\r
- * be written in full. The other names may be abbreviated.\r
- */\r
- if(!partitions[i].precious || (strlen(partitions[i].name) == length)) {\r
- p = &partitions[i];\r
- }\r
- break;\r
- }\r
- }\r
-\r
- if(p == NULL) {\r
- fprintf(stderr, "Warning: area name '");\r
- fwrite(argv[1]+offset, length, 1, stderr);\r
- fprintf(stderr, "' unknown, ignored\n");\r
- } else {\r
- fprintf(stderr, "Flashing %s from %s\n", p->name, argv[2+current_area]);\r
- PrepareFlash(p, argv[2+current_area], state);\r
- }\r
- current_area++;\r
- }\r
-\r
- return 0;\r
-}\r
+++ /dev/null
-#ifndef __PROX_H\r
-#define __PROX_H\r
-\r
-#include "../include/usb_cmd.h"\r
-\r
-// prox.cpp\r
-void ReceiveCommand(UsbCommand *c);\r
-BOOL ReceiveCommandPoll(UsbCommand *c);\r
-void SendCommand(UsbCommand *c, BOOL wantAck);\r
-\r
-// gui.cpp\r
-void ShowGui();\r
-void HideGraphWindow(void);\r
-void ShowGraphWindow(void);\r
-void RepaintGraphWindow(void);\r
-void PrintToScrollback(char *fmt, ...);\r
-#define MAX_GRAPH_TRACE_LEN (1024*128)\r
-extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];\r
-extern int GraphTraceLen;\r
-extern double CursorScaleFactor;\r
-extern int PlotGridX, PlotGridY;\r
-extern int CommandFinished;\r
-extern int offline;\r
-\r
-// command.cpp\r
-static void CmdBuffClear(char *str);\r
-static void GetFromBigBuf(BYTE *dest, int bytes);\r
-static void CmdReset(char *str);\r
-static void CmdQuit(char *str);\r
-static void CmdEM410xread(char *str);\r
-static void CmdEM410xwatch(char *str);\r
-static void ChkBitstream(char *str);\r
-int GetClock(char *str, int peak);\r
-static void CmdHIDdemodFSK(char *str);\r
-static void Cmdmanchestermod(char *str);\r
-static void CmdTune(char *str);\r
-static void CmdHi15read(char *str);\r
-static void CmdHi14read(char *str);\r
-static void CmdSri512read(char *str);\r
-static void CmdHi14areader(char *str);\r
-static void CmdHi15reader(char *str);\r
-static void CmdHi15tag(char *str);\r
-static void CmdHi14read_sim(char *str);\r
-static void CmdHi14readt(char *str);\r
-static void CmdHisimlisten(char *str);\r
-static void CmdReadmem(char *str);\r
-static void CmdHi14sim(char *str);\r
-static void CmdHi14asim(char *str);\r
-static void CmdHi14snoop(char *str);\r
-static void CmdHi14asnoop(char *str);\r
-static void CmdFPGAOff(char *str);\r
-int CmdClearGraph(int redraw);\r
-static void CmdAppendGraph(int redraw, int clock, int bit);\r
-static void CmdEM410xsim(char *str);\r
-static void CmdLosim(char *str);\r
-static void CmdLoCommandRead(char *str);\r
-static void CmdLoread(char *str);\r
-static void CmdLosamples(char *str);\r
-static void CmdBitsamples(char *str);\r
-static void CmdHisamples(char *str);\r
-static int CmdHisamplest(char *str, int nrlow);\r
-static void CmdHexsamples(char *str);\r
-static void CmdHisampless(char *str);\r
-static WORD Iso15693Crc(BYTE *v, int n);\r
-static void CmdHi14bdemod(char *str);\r
-static void CmdHi14list(char *str);\r
-static void CmdHi14alist(char *str);\r
-static void CmdHi15demod(char *str);\r
-static void CmdTiread(char *str);\r
-static void CmdTibits(char *str);\r
-static void CmdTidemod(char *cmdline);\r
-static void CmdNorm(char *str);\r
-static void CmdDec(char *str);\r
-static void CmdHpf(char *str);\r
-static void CmdZerocrossings(char *str);\r
-static void CmdLtrim(char *str);\r
-static void CmdAutoCorr(char *str);\r
-static void CmdVchdemod(char *str);\r
-static void CmdIndalademod(char *str);\r
-static void CmdFlexdemod(char *str);\r
-static void Cmdaskdemod(char *str);\r
-static void Cmddetectclockrate(char *str);\r
-int detectclock(int peak);\r
-static void Cmdbitstream(char *str);\r
-static void Cmdmanchesterdemod(char *str);\r
-static void CmdHiddemod(char *str);\r
-static void CmdPlot(char *str);\r
-static void CmdHide(char *str);\r
-static void CmdScale(char *str);\r
-static void CmdSave(char *str);\r
-static void CmdLoad(char *str);\r
-static void CmdHIDsimTAG(char *str);\r
-static void CmdLcdReset(char *str);\r
-static void CmdLcd(char *str);\r
-static void CmdTest(char *str);\r
-static void CmdSetDivisor(char *str);\r
-static void CmdSweepLF(char *str);\r
-void CommandReceived(char *cmd);\r
-void UsbCommandReceived(UsbCommand *c);\r
-\r
-\r
-// cmdline.cpp\r
-void ShowCommandline(void);\r
-void ExecCmd(char *cmd);\r
-//void PrintToScrollback(char *fmt, ...);\r
-\r
-#endif\r
projects / proxmark3-svn / commitdiff