fix 'hf iclass reader' and 'hf iclass readblk'
[proxmark3-svn] / armsrc / appmain.c
CommitLineData
15c4dc5a 1//-----------------------------------------------------------------------------
15c4dc5a 2// Jonathan Westhues, Mar 2006
3// Edits by Gerhard de Koning Gans, Sep 2007 (##)
bd20f8f4 4//
5// This code is licensed to you under the terms of the GNU GPL, version 2 or,
6// at your option, any later version. See the LICENSE.txt file for the text of
7// the license.
8//-----------------------------------------------------------------------------
9// The main application code. This is the first thing called after start.c
10// executes.
15c4dc5a 11//-----------------------------------------------------------------------------
12
b8e461ff 13#include <stdarg.h>
14
902cb3c0 15#include "usb_cdc.h"
16#include "cmd.h"
e30c654b 17#include "proxmark3.h"
15c4dc5a 18#include "apps.h"
472345da 19#include "fpga.h"
f7e3ed82 20#include "util.h"
9ab7a6c7 21#include "printf.h"
22#include "string.h"
15c4dc5a 23#include "legicrf.h"
1b902aa0 24#include "legicrfsim.h"
b8e461ff 25#include "hitag2.h"
26#include "hitagS.h"
17505ce2 27#include "iclass.h"
5ea2a248 28#include "iso14443b.h"
d9de20fa 29#include "iso15693.h"
31abe49f 30#include "lfsampling.h"
3000dc4e 31#include "BigBuf.h"
0b4efbde 32#include "mifarecmd.h"
c89274cc 33#include "mifareutil.h"
a8561e35 34#include "mifaresim.h"
d10e08ae 35#include "pcf7931.h"
050aa18b 36#include "i2c.h"
fc52fbd4 37#include "hfsnoop.h"
38#include "fpgaloader.h"
15c4dc5a 39#ifdef WITH_LCD
902cb3c0 40 #include "LCD.h"
15c4dc5a 41#endif
43591e64 42
a9104f7e 43static uint32_t hw_capabilities;
15c4dc5a 44
e46fe044 45// Craig Young - 14a stand-alone code
854fdf15 46#ifdef WITH_ISO14443a
e46fe044
CY
47 #include "iso14443a.h"
48#endif
49
15c4dc5a 50//=============================================================================
51// A buffer where we can queue things up to be sent through the FPGA, for
52// any purpose (fake tag, as reader, whatever). We go MSB first, since that
53// is the order in which they go out on the wire.
54//=============================================================================
55
6a1f2d82 56#define TOSEND_BUFFER_SIZE (9*MAX_FRAME_SIZE + 1 + 1 + 2) // 8 data bits and 1 parity bit per payload byte, 1 correction bit, 1 SOC bit, 2 EOC bits
57uint8_t ToSend[TOSEND_BUFFER_SIZE];
15c4dc5a 58int ToSendMax;
59static int ToSendBit;
60struct common_area common_area __attribute__((section(".commonarea")));
61
15c4dc5a 62void ToSendReset(void)
63{
64 ToSendMax = -1;
65 ToSendBit = 8;
66}
67
68void ToSendStuffBit(int b)
69{
70 if(ToSendBit >= 8) {
71 ToSendMax++;
72 ToSend[ToSendMax] = 0;
73 ToSendBit = 0;
74 }
75
76 if(b) {
77 ToSend[ToSendMax] |= (1 << (7 - ToSendBit));
78 }
79
80 ToSendBit++;
81
6a1f2d82 82 if(ToSendMax >= sizeof(ToSend)) {
15c4dc5a 83 ToSendBit = 0;
84 DbpString("ToSendStuffBit overflowed!");
85 }
86}
87
88//=============================================================================
89// Debug print functions, to go out over USB, to the usual PC-side client.
90//=============================================================================
91
92void DbpString(char *str)
93{
9440213d 94 byte_t len = strlen(str);
95 cmd_send(CMD_DEBUG_PRINT_STRING,len,0,0,(byte_t*)str,len);
15c4dc5a 96}
97
98#if 0
99void DbpIntegers(int x1, int x2, int x3)
100{
902cb3c0 101 cmd_send(CMD_DEBUG_PRINT_INTEGERS,x1,x2,x3,0,0);
15c4dc5a 102}
103#endif
104
105void Dbprintf(const char *fmt, ...) {
106// should probably limit size here; oh well, let's just use a big buffer
107 char output_string[128];
108 va_list ap;
109
110 va_start(ap, fmt);
111 kvsprintf(fmt, output_string, 10, ap);
112 va_end(ap);
e30c654b 113
15c4dc5a 114 DbpString(output_string);
115}
116
9455b51c 117// prints HEX & ASCII
d19929cb 118void Dbhexdump(int len, uint8_t *d, bool bAsci) {
9455b51c 119 int l=0,i;
120 char ascii[9];
d19929cb 121
9455b51c 122 while (len>0) {
123 if (len>8) l=8;
124 else l=len;
125
126 memcpy(ascii,d,l);
d19929cb 127 ascii[l]=0;
9455b51c 128
129 // filter safe ascii
d19929cb 130 for (i=0;i<l;i++)
9455b51c 131 if (ascii[i]<32 || ascii[i]>126) ascii[i]='.';
d19929cb 132
133 if (bAsci) {
134 Dbprintf("%-8s %*D",ascii,l,d," ");
135 } else {
136 Dbprintf("%*D",l,d," ");
137 }
138
9455b51c 139 len-=8;
140 d+=8;
141 }
142}
143
15c4dc5a 144//-----------------------------------------------------------------------------
145// Read an ADC channel and block till it completes, then return the result
146// in ADC units (0 to 1023). Also a routine to average 32 samples and
147// return that.
148//-----------------------------------------------------------------------------
149static int ReadAdc(int ch)
2d51da38 150{
3b692427 151 // Note: ADC_MODE_PRESCALE and ADC_MODE_SAMPLE_HOLD_TIME are set to the maximum allowed value.
050aa18b 152 // AMPL_HI is a high impedance (10MOhm || 1MOhm) output, the input capacitance of the ADC is 12pF (typical). This results in a time constant
9b32625c 153 // of RC = (0.91MOhm) * 12pF = 10.9us. Even after the maximum configurable sample&hold time of 40us the input capacitor will not be fully charged.
3b692427 154 //
155 // The maths are:
156 // If there is a voltage v_in at the input, the voltage v_cap at the capacitor (this is what we are measuring) will be
157 //
9b32625c 158 // v_cap = v_in * (1 - exp(-SHTIM/RC)) = v_in * (1 - exp(-40us/10.9us)) = v_in * 0,97 (i.e. an error of 3%)
15c4dc5a 159
2d51da38
I
160 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
161 AT91C_BASE_ADC->ADC_MR =
9b32625c 162 ADC_MODE_PRESCALE(63) | // ADC_CLK = MCK / ((63+1) * 2) = 48MHz / 128 = 375kHz
163 ADC_MODE_STARTUP_TIME(1) | // Startup Time = (1+1) * 8 / ADC_CLK = 16 / 375kHz = 42,7us Note: must be > 20us
164 ADC_MODE_SAMPLE_HOLD_TIME(15); // Sample & Hold Time SHTIM = 15 / ADC_CLK = 15 / 375kHz = 40us
3b692427 165
2d51da38
I
166 AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ch);
167 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
15c4dc5a 168
2d51da38
I
169 while(!(AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ch))) {};
170
050aa18b 171 return AT91C_BASE_ADC->ADC_CDR[ch] & 0x3ff;
15c4dc5a 172}
173
9ca155ba 174int AvgAdc(int ch) // was static - merlok
15c4dc5a 175{
176 int i;
177 int a = 0;
178
179 for(i = 0; i < 32; i++) {
180 a += ReadAdc(ch);
181 }
182
183 return (a + 15) >> 5;
184}
185
050aa18b 186static int AvgAdc_Voltage_HF(void)
187{
188 int AvgAdc_Voltage_Low, AvgAdc_Voltage_High;
189
190 AvgAdc_Voltage_Low= (MAX_ADC_HF_VOLTAGE_LOW * AvgAdc(ADC_CHAN_HF_LOW)) >> 10;
191 // if voltage range is about to be exceeded, use high voltage ADC channel if available (RDV40 only)
192 if (AvgAdc_Voltage_Low > MAX_ADC_HF_VOLTAGE_LOW - 300) {
193 AvgAdc_Voltage_High = (MAX_ADC_HF_VOLTAGE_HIGH * AvgAdc(ADC_CHAN_HF_HIGH)) >> 10;
194 if (AvgAdc_Voltage_High >= AvgAdc_Voltage_Low) {
195 return AvgAdc_Voltage_High;
196 }
197 }
198 return AvgAdc_Voltage_Low;
199}
200
201static int AvgAdc_Voltage_LF(void)
202{
203 return (MAX_ADC_LF_VOLTAGE * AvgAdc(ADC_CHAN_LF)) >> 10;
204}
205
fdcfbdcc 206void MeasureAntennaTuningLfOnly(int *vLf125, int *vLf134, int *peakf, int *peakv, uint8_t LF_Results[])
15c4dc5a 207{
9b32625c 208 int i, adcval = 0, peak = 0;
15c4dc5a 209
210/*
211 * Sweeps the useful LF range of the proxmark from
212 * 46.8kHz (divisor=255) to 600kHz (divisor=19) and
213 * read the voltage in the antenna, the result left
214 * in the buffer is a graph which should clearly show
215 * the resonating frequency of your LF antenna
216 * ( hopefully around 95 if it is tuned to 125kHz!)
217 */
fdcfbdcc
RAB
218
219 FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
b014c96d 220 FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
2d51da38
I
221 SpinDelay(50);
222
2bdd68c3 223 for (i=255; i>=19; i--) {
fdcfbdcc 224 WDT_HIT();
15c4dc5a 225 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, i);
226 SpinDelay(20);
050aa18b 227 adcval = AvgAdc_Voltage_LF();
fdcfbdcc
RAB
228 if (i==95) *vLf125 = adcval; // voltage at 125Khz
229 if (i==89) *vLf134 = adcval; // voltage at 134Khz
15c4dc5a 230
2d51da38 231 LF_Results[i] = adcval >> 9; // scale int to fit in byte for graphing purposes
2bdd68c3 232 if(LF_Results[i] > peak) {
fdcfbdcc 233 *peakv = adcval;
2bdd68c3 234 peak = LF_Results[i];
fdcfbdcc 235 *peakf = i;
9f693930 236 //ptr = i;
15c4dc5a 237 }
238 }
239
2bdd68c3 240 for (i=18; i >= 0; i--) LF_Results[i] = 0;
fdcfbdcc
RAB
241
242 return;
243}
244
245void MeasureAntennaTuningHfOnly(int *vHf)
246{
15c4dc5a 247 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
fdcfbdcc
RAB
248 LED_A_ON();
249 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
5ea2a248 250 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER);
15c4dc5a 251 SpinDelay(20);
050aa18b 252 *vHf = AvgAdc_Voltage_HF();
fdcfbdcc 253 LED_A_OFF();
fdcfbdcc
RAB
254 return;
255}
256
257void MeasureAntennaTuning(int mode)
258{
259 uint8_t LF_Results[256] = {0};
260 int peakv = 0, peakf = 0;
261 int vLf125 = 0, vLf134 = 0, vHf = 0; // in mV
262
263 LED_B_ON();
264
265 if (((mode & FLAG_TUNE_ALL) == FLAG_TUNE_ALL) && (FpgaGetCurrent() == FPGA_BITSTREAM_HF)) {
266 // Reverse "standard" order if HF already loaded, to avoid unnecessary swap.
267 MeasureAntennaTuningHfOnly(&vHf);
268 MeasureAntennaTuningLfOnly(&vLf125, &vLf134, &peakf, &peakv, LF_Results);
269 } else {
270 if (mode & FLAG_TUNE_LF) {
271 MeasureAntennaTuningLfOnly(&vLf125, &vLf134, &peakf, &peakv, LF_Results);
272 }
273 if (mode & FLAG_TUNE_HF) {
274 MeasureAntennaTuningHfOnly(&vHf);
275 }
276 }
15c4dc5a 277
d040cb90 278 cmd_send(CMD_MEASURED_ANTENNA_TUNING, vLf125>>1 | (vLf134>>1<<16), vHf, peakf | (peakv>>1<<16), LF_Results, 256);
d19929cb 279 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
2bdd68c3 280 LED_B_OFF();
281 return;
15c4dc5a 282}
283
284void MeasureAntennaTuningHf(void)
285{
286 int vHf = 0; // in mV
287
288 DbpString("Measuring HF antenna, press button to exit");
289
3b692427 290 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
291 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
5ea2a248 292 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER);
3b692427 293
15c4dc5a 294 for (;;) {
050aa18b 295 SpinDelay(500);
296 vHf = AvgAdc_Voltage_HF();
e30c654b 297
15c4dc5a 298 Dbprintf("%d mV",vHf);
299 if (BUTTON_PRESS()) break;
300 }
301 DbpString("cancelled");
3b692427 302
303 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
304
15c4dc5a 305}
306
307
15c4dc5a 308void ReadMem(int addr)
309{
f7e3ed82 310 const uint8_t *data = ((uint8_t *)addr);
15c4dc5a 311
312 Dbprintf("%x: %02x %02x %02x %02x %02x %02x %02x %02x",
313 addr, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
314}
315
316/* osimage version information is linked in */
317extern struct version_information version_information;
318/* bootrom version information is pointed to from _bootphase1_version_pointer */
0fa01ec7 319extern char *_bootphase1_version_pointer, _flash_start, _flash_end, _bootrom_start, _bootrom_end, __data_src_start__;
472345da 320
050aa18b 321
a9104f7e 322void set_hw_capabilities(void)
323{
324 if (I2C_is_available()) {
325 hw_capabilities |= HAS_SMARTCARD_SLOT;
326 }
327
328 if (false) { // TODO: implement a test
329 hw_capabilities |= HAS_EXTRA_FLASH_MEM;
330 }
331}
332
333
15c4dc5a 334void SendVersion(void)
335{
a9104f7e 336 set_hw_capabilities();
337
8e074056 338 char temp[USB_CMD_DATA_SIZE]; /* Limited data payload in USB packets */
339 char VersionString[USB_CMD_DATA_SIZE] = { '\0' };
e30c654b 340
341 /* Try to find the bootrom version information. Expect to find a pointer at
15c4dc5a 342 * symbol _bootphase1_version_pointer, perform slight sanity checks on the
343 * pointer, then use it.
344 */
345 char *bootrom_version = *(char**)&_bootphase1_version_pointer;
346 if( bootrom_version < &_flash_start || bootrom_version >= &_flash_end ) {
8e074056 347 strcat(VersionString, "bootrom version information appears invalid\n");
15c4dc5a 348 } else {
349 FormatVersionInformation(temp, sizeof(temp), "bootrom: ", bootrom_version);
8e074056 350 strncat(VersionString, temp, sizeof(VersionString) - strlen(VersionString) - 1);
15c4dc5a 351 }
e30c654b 352
15c4dc5a 353 FormatVersionInformation(temp, sizeof(temp), "os: ", &version_information);
8e074056 354 strncat(VersionString, temp, sizeof(VersionString) - strlen(VersionString) - 1);
e30c654b 355
472345da 356 for (int i = 0; i < fpga_bitstream_num; i++) {
357 strncat(VersionString, fpga_version_information[i], sizeof(VersionString) - strlen(VersionString) - 1);
050aa18b 358 strncat(VersionString, "\n", sizeof(VersionString) - strlen(VersionString) - 1);
472345da 359 }
050aa18b 360
361 // test availability of SmartCard slot
362 if (I2C_is_available()) {
363 strncat(VersionString, "SmartCard Slot: available\n", sizeof(VersionString) - strlen(VersionString) - 1);
364 } else {
365 strncat(VersionString, "SmartCard Slot: not available\n", sizeof(VersionString) - strlen(VersionString) - 1);
366 }
367
e6153040 368 // Send Chip ID and used flash memory
0fa01ec7 369 uint32_t text_and_rodata_section_size = (uint32_t)&__data_src_start__ - (uint32_t)&_flash_start;
370 uint32_t compressed_data_section_size = common_area.arg1;
a9104f7e 371 cmd_send(CMD_ACK, *(AT91C_DBGU_CIDR), text_and_rodata_section_size + compressed_data_section_size, hw_capabilities, VersionString, strlen(VersionString));
15c4dc5a 372}
373
bfb01844 374// measure the USB Speed by sending SpeedTestBufferSize bytes to client and measuring the elapsed time.
375// Note: this mimics GetFromBigbuf(), i.e. we have the overhead of the UsbCommand structure included.
67b7d6fa 376void printUSBSpeed(void)
bfb01844 377{
378 Dbprintf("USB Speed:");
67b7d6fa 379 Dbprintf(" Sending USB packets to client...");
bfb01844 380
67b7d6fa 381 #define USB_SPEED_TEST_MIN_TIME 1500 // in milliseconds
bfb01844 382 uint8_t *test_data = BigBuf_get_addr();
67b7d6fa 383 uint32_t end_time;
bfb01844 384
67b7d6fa 385 uint32_t start_time = end_time = GetTickCount();
386 uint32_t bytes_transferred = 0;
387
bfb01844 388 LED_B_ON();
67b7d6fa 389 while(end_time < start_time + USB_SPEED_TEST_MIN_TIME) {
390 cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, 0, USB_CMD_DATA_SIZE, 0, test_data, USB_CMD_DATA_SIZE);
391 end_time = GetTickCount();
392 bytes_transferred += USB_CMD_DATA_SIZE;
bfb01844 393 }
394 LED_B_OFF();
395
67b7d6fa 396 Dbprintf(" Time elapsed: %dms", end_time - start_time);
397 Dbprintf(" Bytes transferred: %d", bytes_transferred);
398 Dbprintf(" USB Transfer Speed PM3 -> Client = %d Bytes/s",
399 1000 * bytes_transferred / (end_time - start_time));
bfb01844 400
401}
402
c89274cc
CY
403/**
404 * Prints runtime information about the PM3.
405**/
67b7d6fa 406void SendStatus(void)
c89274cc
CY
407{
408 BigBuf_print_status();
409 Fpga_print_status();
43591e64 410#ifdef WITH_SMARTCARD
411 I2C_print_status();
412#endif
c89274cc 413 printConfig(); //LF Sampling config
67b7d6fa 414 printUSBSpeed();
c89274cc 415 Dbprintf("Various");
43591e64 416 Dbprintf(" MF_DBGLEVEL........%d", MF_DBGLEVEL);
417 Dbprintf(" ToSendMax..........%d", ToSendMax);
418 Dbprintf(" ToSendBit..........%d", ToSendBit);
bfb01844 419
420 cmd_send(CMD_ACK,1,0,0,0,0);
c89274cc 421}
15c4dc5a 422
a2937cea 423#if defined(WITH_ISO14443a_StandAlone) || defined(WITH_LF_StandAlone)
15c4dc5a 424
15c4dc5a 425#define OPTS 2
426
86a83668
MHS
427void StandAloneMode()
428{
429 DbpString("Stand-alone mode! No PC necessary.");
15c4dc5a 430 // Oooh pretty -- notify user we're in elite samy mode now
431 LED(LED_RED, 200);
432 LED(LED_ORANGE, 200);
433 LED(LED_GREEN, 200);
434 LED(LED_ORANGE, 200);
435 LED(LED_RED, 200);
436 LED(LED_ORANGE, 200);
437 LED(LED_GREEN, 200);
438 LED(LED_ORANGE, 200);
439 LED(LED_RED, 200);
440
86a83668
MHS
441}
442
443#endif
444
445
446
447#ifdef WITH_ISO14443a_StandAlone
448void StandAloneMode14a()
449{
450 StandAloneMode();
451 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
452
15c4dc5a 453 int selected = 0;
44964fd1 454 bool playing = false, GotoRecord = false, GotoClone = false;
455 bool cardRead[OPTS] = {false};
86a83668
MHS
456 uint8_t readUID[10] = {0};
457 uint32_t uid_1st[OPTS]={0};
458 uint32_t uid_2nd[OPTS]={0};
c89274cc
CY
459 uint32_t uid_tmp1 = 0;
460 uint32_t uid_tmp2 = 0;
461 iso14a_card_select_t hi14a_card[OPTS];
15c4dc5a 462
15c4dc5a 463 LED(selected + 1, 0);
464
465 for (;;)
466 {
6e82300d 467 usb_poll();
86a83668 468 WDT_HIT();
15c4dc5a 469 SpinDelay(300);
470
44964fd1 471 if (GotoRecord || !cardRead[selected])
15c4dc5a 472 {
44964fd1 473 GotoRecord = false;
15c4dc5a 474 LEDsoff();
475 LED(selected + 1, 0);
476 LED(LED_RED2, 0);
477
478 // record
86a83668 479 Dbprintf("Enabling iso14443a reader mode for [Bank: %u]...", selected);
15c4dc5a 480 /* need this delay to prevent catching some weird data */
481 SpinDelay(500);
86a83668
MHS
482 /* Code for reading from 14a tag */
483 uint8_t uid[10] ={0};
484 uint32_t cuid;
485 iso14443a_setup(FPGA_HF_ISO14443A_READER_MOD);
15c4dc5a 486
86a83668
MHS
487 for ( ; ; )
488 {
489 WDT_HIT();
c89274cc
CY
490 if (BUTTON_PRESS()) {
491 if (cardRead[selected]) {
492 Dbprintf("Button press detected -- replaying card in bank[%d]", selected);
493 break;
494 }
495 else if (cardRead[(selected+1)%OPTS]) {
496 Dbprintf("Button press detected but no card in bank[%d] so playing from bank[%d]", selected, (selected+1)%OPTS);
497 selected = (selected+1)%OPTS;
44964fd1 498 break;
c89274cc
CY
499 }
500 else {
501 Dbprintf("Button press detected but no stored tag to play. (Ignoring button)");
502 SpinDelay(300);
503 }
504 }
c04a4b60 505 if (!iso14443a_select_card(uid, &hi14a_card[selected], &cuid, true, 0, true))
86a83668
MHS
506 continue;
507 else
508 {
509 Dbprintf("Read UID:"); Dbhexdump(10,uid,0);
510 memcpy(readUID,uid,10*sizeof(uint8_t));
c89274cc 511 uint8_t *dst = (uint8_t *)&uid_tmp1;
86a83668
MHS
512 // Set UID byte order
513 for (int i=0; i<4; i++)
514 dst[i] = uid[3-i];
c89274cc 515 dst = (uint8_t *)&uid_tmp2;
86a83668
MHS
516 for (int i=0; i<4; i++)
517 dst[i] = uid[7-i];
c89274cc
CY
518 if (uid_1st[(selected+1)%OPTS] == uid_tmp1 && uid_2nd[(selected+1)%OPTS] == uid_tmp2) {
519 Dbprintf("Card selected has same UID as what is stored in the other bank. Skipping.");
520 }
521 else {
522 if (uid_tmp2) {
523 Dbprintf("Bank[%d] received a 7-byte UID",selected);
524 uid_1st[selected] = (uid_tmp1)>>8;
525 uid_2nd[selected] = (uid_tmp1<<24) + (uid_tmp2>>8);
526 }
527 else {
528 Dbprintf("Bank[%d] received a 4-byte UID",selected);
529 uid_1st[selected] = uid_tmp1;
530 uid_2nd[selected] = uid_tmp2;
531 }
532 break;
533 }
86a83668
MHS
534 }
535 }
c89274cc
CY
536 Dbprintf("ATQA = %02X%02X",hi14a_card[selected].atqa[0],hi14a_card[selected].atqa[1]);
537 Dbprintf("SAK = %02X",hi14a_card[selected].sak);
86a83668
MHS
538 LEDsoff();
539 LED(LED_GREEN, 200);
540 LED(LED_ORANGE, 200);
541 LED(LED_GREEN, 200);
542 LED(LED_ORANGE, 200);
15c4dc5a 543
544 LEDsoff();
545 LED(selected + 1, 0);
15c4dc5a 546
c89274cc 547 // Next state is replay:
44964fd1 548 playing = true;
3fe4ff4f 549
44964fd1 550 cardRead[selected] = true;
86a83668 551 }
c89274cc 552 /* MF Classic UID clone */
44964fd1 553 else if (GotoClone)
3fe4ff4f 554 {
44964fd1 555 GotoClone=false;
c89274cc
CY
556 LEDsoff();
557 LED(selected + 1, 0);
558 LED(LED_ORANGE, 250);
3fe4ff4f 559
3fe4ff4f 560
c89274cc
CY
561 // record
562 Dbprintf("Preparing to Clone card [Bank: %x]; uid: %08x", selected, uid_1st[selected]);
3fe4ff4f 563
c89274cc
CY
564 // wait for button to be released
565 while(BUTTON_PRESS())
566 {
567 // Delay cloning until card is in place
568 WDT_HIT();
569 }
570 Dbprintf("Starting clone. [Bank: %u]", selected);
571 // need this delay to prevent catching some weird data
572 SpinDelay(500);
573 // Begin clone function here:
574 /* Example from client/mifarehost.c for commanding a block write for "magic Chinese" cards:
575 UsbCommand c = {CMD_MIFARE_CSETBLOCK, {wantWipe, params & (0xFE | (uid == NULL ? 0:1)), blockNo}};
576 memcpy(c.d.asBytes, data, 16);
577 SendCommand(&c);
578
579 Block read is similar:
580 UsbCommand c = {CMD_MIFARE_CGETBLOCK, {params, 0, blockNo}};
581 We need to imitate that call with blockNo 0 to set a uid.
582
583 The get and set commands are handled in this file:
584 // Work with "magic Chinese" card
585 case CMD_MIFARE_CSETBLOCK:
586 MifareCSetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
587 break;
588 case CMD_MIFARE_CGETBLOCK:
589 MifareCGetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
590 break;
591
592 mfCSetUID provides example logic for UID set workflow:
593 -Read block0 from card in field with MifareCGetBlock()
594 -Configure new values without replacing reserved bytes
595 memcpy(block0, uid, 4); // Copy UID bytes from byte array
596 // Mifare UID BCC
597 block0[4] = block0[0]^block0[1]^block0[2]^block0[3]; // BCC on byte 5
598 Bytes 5-7 are reserved SAK and ATQA for mifare classic
599 -Use mfCSetBlock(0, block0, oldUID, wantWipe, CSETBLOCK_SINGLE_OPER) to write it
600 */
601 uint8_t oldBlock0[16] = {0}, newBlock0[16] = {0}, testBlock0[16] = {0};
602 // arg0 = Flags == CSETBLOCK_SINGLE_OPER=0x1F, arg1=returnSlot, arg2=blockNo
603 MifareCGetBlock(0x3F, 1, 0, oldBlock0);
604 if (oldBlock0[0] == 0 && oldBlock0[0] == oldBlock0[1] && oldBlock0[1] == oldBlock0[2] && oldBlock0[2] == oldBlock0[3]) {
605 Dbprintf("No changeable tag detected. Returning to replay mode for bank[%d]", selected);
44964fd1 606 playing = true;
c89274cc
CY
607 }
608 else {
609 Dbprintf("UID from target tag: %02X%02X%02X%02X", oldBlock0[0],oldBlock0[1],oldBlock0[2],oldBlock0[3]);
610 memcpy(newBlock0,oldBlock0,16);
611 // Copy uid_1st for bank (2nd is for longer UIDs not supported if classic)
612
613 newBlock0[0] = uid_1st[selected]>>24;
614 newBlock0[1] = 0xFF & (uid_1st[selected]>>16);
615 newBlock0[2] = 0xFF & (uid_1st[selected]>>8);
616 newBlock0[3] = 0xFF & (uid_1st[selected]);
617 newBlock0[4] = newBlock0[0]^newBlock0[1]^newBlock0[2]^newBlock0[3];
618 // arg0 = needWipe, arg1 = workFlags, arg2 = blockNo, datain
619 MifareCSetBlock(0, 0xFF,0, newBlock0);
620 MifareCGetBlock(0x3F, 1, 0, testBlock0);
621 if (memcmp(testBlock0,newBlock0,16)==0)
622 {
623 DbpString("Cloned successfull!");
44964fd1 624 cardRead[selected] = false; // Only if the card was cloned successfully should we clear it
625 playing = false;
626 GotoRecord = true;
c89274cc
CY
627 selected = (selected+1) % OPTS;
628 }
629 else {
630 Dbprintf("Clone failed. Back to replay mode on bank[%d]", selected);
44964fd1 631 playing = true;
c89274cc
CY
632 }
633 }
634 LEDsoff();
635 LED(selected + 1, 0);
15c4dc5a 636
86a83668 637 }
15c4dc5a 638 // Change where to record (or begin playing)
44964fd1 639 else if (playing) // button_pressed == BUTTON_SINGLE_CLICK && cardRead[selected])
15c4dc5a 640 {
15c4dc5a 641 LEDsoff();
642 LED(selected + 1, 0);
643
644 // Begin transmitting
44964fd1 645 LED(LED_GREEN, 0);
646 DbpString("Playing");
647 for ( ; ; ) {
648 WDT_HIT();
649 int button_action = BUTTON_HELD(1000);
650 if (button_action == 0) { // No button action, proceed with sim
651 uint8_t data[512] = {0}; // in case there is a read command received we shouldn't break
652 Dbprintf("Simulating ISO14443a tag with uid[0]: %08x, uid[1]: %08x [Bank: %u]", uid_1st[selected],uid_2nd[selected],selected);
653 if (hi14a_card[selected].sak == 8 && hi14a_card[selected].atqa[0] == 4 && hi14a_card[selected].atqa[1] == 0) {
654 DbpString("Mifare Classic");
655 SimulateIso14443aTag(1,uid_1st[selected], uid_2nd[selected], data); // Mifare Classic
c89274cc 656 }
44964fd1 657 else if (hi14a_card[selected].sak == 0 && hi14a_card[selected].atqa[0] == 0x44 && hi14a_card[selected].atqa[1] == 0) {
658 DbpString("Mifare Ultralight");
659 SimulateIso14443aTag(2,uid_1st[selected],uid_2nd[selected],data); // Mifare Ultralight
15c4dc5a 660 }
44964fd1 661 else if (hi14a_card[selected].sak == 20 && hi14a_card[selected].atqa[0] == 0x44 && hi14a_card[selected].atqa[1] == 3) {
662 DbpString("Mifare DESFire");
663 SimulateIso14443aTag(3,uid_1st[selected],uid_2nd[selected],data); // Mifare DESFire
664 }
665 else {
666 Dbprintf("Unrecognized tag type -- defaulting to Mifare Classic emulation");
667 SimulateIso14443aTag(1,uid_1st[selected], uid_2nd[selected], data);
c89274cc 668 }
c89274cc 669 }
44964fd1 670 else if (button_action == BUTTON_SINGLE_CLICK) {
671 selected = (selected + 1) % OPTS;
672 Dbprintf("Done playing. Switching to record mode on bank %d",selected);
673 GotoRecord = true;
674 break;
675 }
676 else if (button_action == BUTTON_HOLD) {
677 Dbprintf("Playtime over. Begin cloning...");
678 GotoClone = true;
679 break;
680 }
681 WDT_HIT();
15c4dc5a 682 }
44964fd1 683
684 /* We pressed a button so ignore it here with a delay */
685 SpinDelay(300);
686 LEDsoff();
687 LED(selected + 1, 0);
15c4dc5a 688 }
689 }
690}
a2937cea 691#elif WITH_LF_StandAlone
86a83668
MHS
692// samy's sniff and repeat routine
693void SamyRun()
e46fe044 694{
86a83668
MHS
695 StandAloneMode();
696 FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
e46fe044 697
53e2f2fa 698 int tops[OPTS], high[OPTS], low[OPTS];
15c4dc5a 699 int selected = 0;
700 int playing = 0;
3fe4ff4f 701 int cardRead = 0;
15c4dc5a 702
703 // Turn on selected LED
704 LED(selected + 1, 0);
705
706 for (;;)
707 {
6e82300d 708 usb_poll();
86a83668 709 WDT_HIT();
15c4dc5a 710
711 // Was our button held down or pressed?
712 int button_pressed = BUTTON_HELD(1000);
713 SpinDelay(300);
714
715 // Button was held for a second, begin recording
3fe4ff4f 716 if (button_pressed > 0 && cardRead == 0)
15c4dc5a 717 {
718 LEDsoff();
719 LED(selected + 1, 0);
720 LED(LED_RED2, 0);
721
722 // record
723 DbpString("Starting recording");
724
725 // wait for button to be released
726 while(BUTTON_PRESS())
727 WDT_HIT();
728
729 /* need this delay to prevent catching some weird data */
730 SpinDelay(500);
731
53e2f2fa 732 CmdHIDdemodFSK(1, &tops[selected], &high[selected], &low[selected], 0);
733 if (tops[selected] > 0)
734 Dbprintf("Recorded %x %x%08x%08x", selected, tops[selected], high[selected], low[selected]);
735 else
736 Dbprintf("Recorded %x %x%08x", selected, high[selected], low[selected]);
15c4dc5a 737
738 LEDsoff();
739 LED(selected + 1, 0);
740 // Finished recording
741
742 // If we were previously playing, set playing off
743 // so next button push begins playing what we recorded
744 playing = 0;
3fe4ff4f 745
746 cardRead = 1;
747
748 }
749
750 else if (button_pressed > 0 && cardRead == 1)
751 {
752 LEDsoff();
753 LED(selected + 1, 0);
754 LED(LED_ORANGE, 0);
755
756 // record
53e2f2fa 757 if (tops[selected] > 0)
758 Dbprintf("Cloning %x %x%08x%08x", selected, tops[selected], high[selected], low[selected]);
759 else
760 Dbprintf("Cloning %x %x%08x", selected, high[selected], low[selected]);
3fe4ff4f 761
762 // wait for button to be released
763 while(BUTTON_PRESS())
764 WDT_HIT();
765
766 /* need this delay to prevent catching some weird data */
767 SpinDelay(500);
768
5f84531b 769 CopyHIDtoT55x7(tops[selected] & 0x000FFFFF, high[selected], low[selected], (tops[selected] != 0 && ((high[selected]& 0xFFFFFFC0) != 0)), 0x1D);
53e2f2fa 770 if (tops[selected] > 0)
771 Dbprintf("Cloned %x %x%08x%08x", selected, tops[selected], high[selected], low[selected]);
772 else
773 Dbprintf("Cloned %x %x%08x", selected, high[selected], low[selected]);
3fe4ff4f 774
775 LEDsoff();
776 LED(selected + 1, 0);
777 // Finished recording
778
779 // If we were previously playing, set playing off
780 // so next button push begins playing what we recorded
781 playing = 0;
782
783 cardRead = 0;
784
15c4dc5a 785 }
786
787 // Change where to record (or begin playing)
788 else if (button_pressed)
789 {
790 // Next option if we were previously playing
791 if (playing)
792 selected = (selected + 1) % OPTS;
793 playing = !playing;
794
795 LEDsoff();
796 LED(selected + 1, 0);
797
798 // Begin transmitting
799 if (playing)
800 {
801 LED(LED_GREEN, 0);
802 DbpString("Playing");
803 // wait for button to be released
804 while(BUTTON_PRESS())
805 WDT_HIT();
53e2f2fa 806 if (tops[selected] > 0)
807 Dbprintf("%x %x%08x%08x", selected, tops[selected], high[selected], low[selected]);
808 else
809 Dbprintf("%x %x%08x", selected, high[selected], low[selected]);
810
811 CmdHIDsimTAG(tops[selected], high[selected], low[selected], 0);
15c4dc5a 812 DbpString("Done playing");
813 if (BUTTON_HELD(1000) > 0)
814 {
815 DbpString("Exiting");
816 LEDsoff();
817 return;
818 }
819
820 /* We pressed a button so ignore it here with a delay */
821 SpinDelay(300);
822
823 // when done, we're done playing, move to next option
824 selected = (selected + 1) % OPTS;
825 playing = !playing;
826 LEDsoff();
827 LED(selected + 1, 0);
828 }
829 else
830 while(BUTTON_PRESS())
831 WDT_HIT();
832 }
833 }
834}
15c4dc5a 835
e46fe044 836#endif
15c4dc5a 837/*
838OBJECTIVE
839Listen and detect an external reader. Determine the best location
840for the antenna.
841
842INSTRUCTIONS:
843Inside the ListenReaderField() function, there is two mode.
844By default, when you call the function, you will enter mode 1.
845If you press the PM3 button one time, you will enter mode 2.
846If you press the PM3 button a second time, you will exit the function.
847
848DESCRIPTION OF MODE 1:
849This mode just listens for an external reader field and lights up green
850for HF and/or red for LF. This is the original mode of the detectreader
851function.
852
853DESCRIPTION OF MODE 2:
854This mode will visually represent, using the LEDs, the actual strength of the
855current compared to the maximum current detected. Basically, once you know
856what kind of external reader is present, it will help you spot the best location to place
857your antenna. You will probably not get some good results if there is a LF and a HF reader
858at the same place! :-)
859
860LIGHT SCHEME USED:
861*/
862static const char LIGHT_SCHEME[] = {
863 0x0, /* ---- | No field detected */
864 0x1, /* X--- | 14% of maximum current detected */
865 0x2, /* -X-- | 29% of maximum current detected */
866 0x4, /* --X- | 43% of maximum current detected */
867 0x8, /* ---X | 57% of maximum current detected */
868 0xC, /* --XX | 71% of maximum current detected */
869 0xE, /* -XXX | 86% of maximum current detected */
870 0xF, /* XXXX | 100% of maximum current detected */
871};
872static const int LIGHT_LEN = sizeof(LIGHT_SCHEME)/sizeof(LIGHT_SCHEME[0]);
873
874void ListenReaderField(int limit)
875{
050aa18b 876 int lf_av, lf_av_new=0, lf_baseline= 0, lf_max;
877 int hf_av, hf_av_new=0, hf_baseline= 0, hf_max;
15c4dc5a 878 int mode=1, display_val, display_max, i;
879
050aa18b 880#define LF_ONLY 1
881#define HF_ONLY 2
882#define REPORT_CHANGE_PERCENT 5 // report new values only if they have changed at least by REPORT_CHANGE_PERCENT
883#define MIN_HF_FIELD 300 // in mode 1 signal HF field greater than MIN_HF_FIELD above baseline
884#define MIN_LF_FIELD 1200 // in mode 1 signal LF field greater than MIN_LF_FIELD above baseline
3b692427 885
886
887 // switch off FPGA - we don't want to measure our own signal
888 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
889 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
15c4dc5a 890
891 LEDsoff();
892
050aa18b 893 lf_av = lf_max = AvgAdc_Voltage_LF();
15c4dc5a 894
895 if(limit != HF_ONLY) {
050aa18b 896 Dbprintf("LF 125/134kHz Baseline: %dmV", lf_av);
15c4dc5a 897 lf_baseline = lf_av;
898 }
899
050aa18b 900 hf_av = hf_max = AvgAdc_Voltage_HF();
901
15c4dc5a 902 if (limit != LF_ONLY) {
050aa18b 903 Dbprintf("HF 13.56MHz Baseline: %dmV", hf_av);
15c4dc5a 904 hf_baseline = hf_av;
905 }
906
907 for(;;) {
050aa18b 908 SpinDelay(500);
15c4dc5a 909 if (BUTTON_PRESS()) {
15c4dc5a 910 switch (mode) {
911 case 1:
912 mode=2;
913 DbpString("Signal Strength Mode");
914 break;
915 case 2:
916 default:
917 DbpString("Stopped");
918 LEDsoff();
919 return;
920 break;
921 }
050aa18b 922 while (BUTTON_PRESS());
15c4dc5a 923 }
924 WDT_HIT();
925
926 if (limit != HF_ONLY) {
3b692427 927 if(mode == 1) {
050aa18b 928 if (lf_av - lf_baseline > MIN_LF_FIELD)
3b692427 929 LED_D_ON();
930 else
931 LED_D_OFF();
15c4dc5a 932 }
e30c654b 933
050aa18b 934 lf_av_new = AvgAdc_Voltage_LF();
15c4dc5a 935 // see if there's a significant change
050aa18b 936 if (ABS((lf_av - lf_av_new)*100/(lf_av?lf_av:1)) > REPORT_CHANGE_PERCENT) {
937 Dbprintf("LF 125/134kHz Field Change: %5dmV", lf_av_new);
15c4dc5a 938 lf_av = lf_av_new;
939 if (lf_av > lf_max)
940 lf_max = lf_av;
15c4dc5a 941 }
942 }
943
944 if (limit != LF_ONLY) {
945 if (mode == 1){
050aa18b 946 if (hf_av - hf_baseline > MIN_HF_FIELD)
3b692427 947 LED_B_ON();
948 else
949 LED_B_OFF();
15c4dc5a 950 }
e30c654b 951
050aa18b 952 hf_av_new = AvgAdc_Voltage_HF();
953
15c4dc5a 954 // see if there's a significant change
050aa18b 955 if (ABS((hf_av - hf_av_new)*100/(hf_av?hf_av:1)) > REPORT_CHANGE_PERCENT) {
956 Dbprintf("HF 13.56MHz Field Change: %5dmV", hf_av_new);
15c4dc5a 957 hf_av = hf_av_new;
958 if (hf_av > hf_max)
959 hf_max = hf_av;
15c4dc5a 960 }
961 }
e30c654b 962
15c4dc5a 963 if(mode == 2) {
964 if (limit == LF_ONLY) {
965 display_val = lf_av;
966 display_max = lf_max;
967 } else if (limit == HF_ONLY) {
968 display_val = hf_av;
969 display_max = hf_max;
970 } else { /* Pick one at random */
971 if( (hf_max - hf_baseline) > (lf_max - lf_baseline) ) {
972 display_val = hf_av;
973 display_max = hf_max;
974 } else {
975 display_val = lf_av;
976 display_max = lf_max;
977 }
978 }
979 for (i=0; i<LIGHT_LEN; i++) {
980 if (display_val >= ((display_max/LIGHT_LEN)*i) && display_val <= ((display_max/LIGHT_LEN)*(i+1))) {
981 if (LIGHT_SCHEME[i] & 0x1) LED_C_ON(); else LED_C_OFF();
982 if (LIGHT_SCHEME[i] & 0x2) LED_A_ON(); else LED_A_OFF();
983 if (LIGHT_SCHEME[i] & 0x4) LED_B_ON(); else LED_B_OFF();
984 if (LIGHT_SCHEME[i] & 0x8) LED_D_ON(); else LED_D_OFF();
985 break;
986 }
987 }
988 }
989 }
990}
991
f7e3ed82 992void UsbPacketReceived(uint8_t *packet, int len)
15c4dc5a 993{
994 UsbCommand *c = (UsbCommand *)packet;
15c4dc5a 995
902cb3c0 996// Dbprintf("received %d bytes, with command: 0x%04x and args: %d %d %d",len,c->cmd,c->arg[0],c->arg[1],c->arg[2]);
997
15c4dc5a 998 switch(c->cmd) {
999#ifdef WITH_LF
31abe49f 1000 case CMD_SET_LF_SAMPLING_CONFIG:
70dbfc3f 1001 setSamplingConfig(c->d.asBytes);
31abe49f 1002 break;
15c4dc5a 1003 case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
b9957414 1004 cmd_send(CMD_ACK,SampleLF(c->arg[0], c->arg[1]),0,0,0,0);
15c4dc5a 1005 break;
15c4dc5a 1006 case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
1007 ModThenAcquireRawAdcSamples125k(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
1008 break;
b014c96d 1009 case CMD_LF_SNOOP_RAW_ADC_SAMPLES:
31abe49f 1010 cmd_send(CMD_ACK,SnoopLF(),0,0,0,0);
b014c96d 1011 break;
7e67e42f 1012 case CMD_HID_DEMOD_FSK:
be59094d 1013 CmdHIDdemodFSK(c->arg[0], 0, 0, 0, 1);
7e67e42f 1014 break;
1015 case CMD_HID_SIM_TAG:
be59094d 1016 CmdHIDsimTAG(c->arg[0], c->arg[1], c->arg[2], 1);
7e67e42f 1017 break;
abd6112f 1018 case CMD_FSK_SIM_TAG:
1019 CmdFSKsimTAG(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1020 break;
1021 case CMD_ASK_SIM_TAG:
1022 CmdASKsimTag(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1023 break;
872e3d4d 1024 case CMD_PSK_SIM_TAG:
1025 CmdPSKsimTag(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1026 break;
1027 case CMD_HID_CLONE_TAG:
5f84531b
SS
1028 CopyHIDtoT55x7(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0], 0x1D);
1029 break;
1030 case CMD_PARADOX_CLONE_TAG:
1031 // Paradox cards are the same as HID, with a different preamble, so we can reuse the same function
1032 CopyHIDtoT55x7(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0], 0x0F);
7e67e42f 1033 break;
a1f3bb12 1034 case CMD_IO_DEMOD_FSK:
3fe4ff4f 1035 CmdIOdemodFSK(c->arg[0], 0, 0, 1);
a1f3bb12 1036 break;
3fe4ff4f 1037 case CMD_IO_CLONE_TAG:
9f669cb2 1038 CopyIOtoT55x7(c->arg[0], c->arg[1]);
a1f3bb12 1039 break;
66707a3b 1040 case CMD_EM410X_DEMOD:
1041 CmdEM410xdemod(c->arg[0], 0, 0, 1);
1042 break;
2d4eae76 1043 case CMD_EM410X_WRITE_TAG:
1044 WriteEM410x(c->arg[0], c->arg[1], c->arg[2]);
1045 break;
7e67e42f 1046 case CMD_READ_TI_TYPE:
1047 ReadTItag();
1048 break;
1049 case CMD_WRITE_TI_TYPE:
1050 WriteTItag(c->arg[0],c->arg[1],c->arg[2]);
1051 break;
1052 case CMD_SIMULATE_TAG_125K:
31d1caa5 1053 LED_A_ON();
7e67e42f 1054 SimulateTagLowFrequency(c->arg[0], c->arg[1], 1);
31d1caa5 1055 LED_A_OFF();
7e67e42f 1056 break;
1057 case CMD_LF_SIMULATE_BIDIR:
1058 SimulateTagLowFrequencyBidir(c->arg[0], c->arg[1]);
1059 break;
3fe4ff4f 1060 case CMD_INDALA_CLONE_TAG:
2414f978 1061 CopyIndala64toT55x7(c->arg[0], c->arg[1]);
1062 break;
3fe4ff4f 1063 case CMD_INDALA_CLONE_TAG_L:
2414f978 1064 CopyIndala224toT55x7(c->d.asDwords[0], c->d.asDwords[1], c->d.asDwords[2], c->d.asDwords[3], c->d.asDwords[4], c->d.asDwords[5], c->d.asDwords[6]);
1065 break;
1c611bbd 1066 case CMD_T55XX_READ_BLOCK:
8e99ec25 1067 T55xxReadBlock(c->arg[0], c->arg[1], c->arg[2]);
1c611bbd 1068 break;
1069 case CMD_T55XX_WRITE_BLOCK:
1070 T55xxWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
1071 break;
be2d41b7 1072 case CMD_T55XX_WAKEUP:
1073 T55xxWakeUp(c->arg[0]);
1c611bbd 1074 break;
66837a03 1075 case CMD_T55XX_RESET_READ:
1076 T55xxResetRead();
1077 break;
3fe4ff4f 1078 case CMD_PCF7931_READ:
1c611bbd 1079 ReadPCF7931();
1c611bbd 1080 break;
dc4300ba 1081 case CMD_PCF7931_WRITE:
d10e08ae 1082 WritePCF7931(c->d.asBytes[0],c->d.asBytes[1],c->d.asBytes[2],c->d.asBytes[3],c->d.asBytes[4],c->d.asBytes[5],c->d.asBytes[6], c->d.asBytes[9], c->d.asBytes[7]-128,c->d.asBytes[8]-128, c->arg[0], c->arg[1], c->arg[2]);
dc4300ba 1083 break;
818e15b0
S
1084 case CMD_PCF7931_BRUTEFORCE:
1085 BruteForcePCF7931(c->arg[0], (c->arg[1] & 0xFF), c->d.asBytes[9], c->d.asBytes[7]-128,c->d.asBytes[8]-128);
1086 break;
1c611bbd 1087 case CMD_EM4X_READ_WORD:
7666f460 1088 EM4xReadWord(c->arg[0], c->arg[1],c->arg[2]);
1c611bbd 1089 break;
1090 case CMD_EM4X_WRITE_WORD:
7666f460 1091 EM4xWriteWord(c->arg[0], c->arg[1], c->arg[2]);
1c611bbd 1092 break;
2de26056 1093 case CMD_EM4X_PROTECT:
1094 EM4xProtect(c->arg[0], c->arg[1], c->arg[2]);
1095 break;
dbf6e824
CY
1096 case CMD_AWID_DEMOD_FSK: // Set realtime AWID demodulation
1097 CmdAWIDdemodFSK(c->arg[0], 0, 0, 1);
7cfc777b 1098 break;
709665b5 1099 case CMD_VIKING_CLONE_TAG:
1100 CopyVikingtoT55xx(c->arg[0], c->arg[1], c->arg[2]);
1101 break;
e04475c4 1102 case CMD_COTAG:
1103 Cotag(c->arg[0]);
1104 break;
15c4dc5a 1105#endif
1106
d19929cb 1107#ifdef WITH_HITAG
1108 case CMD_SNOOP_HITAG: // Eavesdrop Hitag tag, args = type
1109 SnoopHitag(c->arg[0]);
1110 break;
1111 case CMD_SIMULATE_HITAG: // Simulate Hitag tag, args = memory content
1112 SimulateHitagTag((bool)c->arg[0],(byte_t*)c->d.asBytes);
1113 break;
1114 case CMD_READER_HITAG: // Reader for Hitag tags, args = type and function
1115 ReaderHitag((hitag_function)c->arg[0],(hitag_data*)c->d.asBytes);
1116 break;
4e12287d
RS
1117 case CMD_SIMULATE_HITAG_S:// Simulate Hitag s tag, args = memory content
1118 SimulateHitagSTag((bool)c->arg[0],(byte_t*)c->d.asBytes);
1119 break;
1120 case CMD_TEST_HITAGS_TRACES:// Tests every challenge within the given file
7b6e3205 1121 check_challenges_cmd((bool)c->arg[0], (byte_t*)c->d.asBytes, (uint8_t)c->arg[1]);
4e12287d
RS
1122 break;
1123 case CMD_READ_HITAG_S://Reader for only Hitag S tags, args = key or challenge
7b6e3205 1124 ReadHitagSCmd((hitag_function)c->arg[0], (hitag_data*)c->d.asBytes, (uint8_t)c->arg[1], (uint8_t)c->arg[2], false);
1125 break;
1126 case CMD_READ_HITAG_S_BLK:
1127 ReadHitagSCmd((hitag_function)c->arg[0], (hitag_data*)c->d.asBytes, (uint8_t)c->arg[1], (uint8_t)c->arg[2], true);
4e12287d
RS
1128 break;
1129 case CMD_WR_HITAG_S://writer for Hitag tags args=data to write,page and key or challenge
52244230
HJ
1130 if ((hitag_function)c->arg[0] < 10) {
1131 WritePageHitagS((hitag_function)c->arg[0],(hitag_data*)c->d.asBytes,c->arg[2]);
1132 }
1133 else if ((hitag_function)c->arg[0] >= 10) {
1134 WriterHitag((hitag_function)c->arg[0],(hitag_data*)c->d.asBytes, c->arg[2]);
1135 }
4e12287d 1136 break;
d19929cb 1137#endif
f168b263 1138
15c4dc5a 1139#ifdef WITH_ISO15693
1140 case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693:
1141 AcquireRawAdcSamplesIso15693();
1142 break;
d9de20fa 1143
1144 case CMD_SNOOP_ISO_15693:
1145 SnoopIso15693();
9455b51c 1146 break;
1147
1148 case CMD_ISO_15693_COMMAND:
1149 DirectTag15693Command(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
1150 break;
1151
1152 case CMD_ISO_15693_FIND_AFI:
1153 BruteforceIso15693Afi(c->arg[0]);
1154 break;
1155
1156 case CMD_ISO_15693_DEBUG:
1157 SetDebugIso15693(c->arg[0]);
1158 break;
15c4dc5a 1159
15c4dc5a 1160 case CMD_READER_ISO_15693:
1161 ReaderIso15693(c->arg[0]);
1162 break;
096dee17 1163
7e67e42f 1164 case CMD_SIMTAG_ISO_15693:
3fe4ff4f 1165 SimTagIso15693(c->arg[0], c->d.asBytes);
7e67e42f 1166 break;
096dee17 1167
1168 case CMD_CSETUID_ISO_15693:
1169 SetTag15693Uid(c->d.asBytes);
1170 break;
15c4dc5a 1171#endif
1172
7e67e42f 1173#ifdef WITH_LEGICRF
1174 case CMD_SIMULATE_TAG_LEGIC_RF:
1b902aa0 1175 LegicRfSimulate(c->arg[0]);
7e67e42f 1176 break;
3612a8a8 1177
7e67e42f 1178 case CMD_WRITER_LEGIC_RF:
1179 LegicRfWriter(c->arg[1], c->arg[0]);
1180 break;
3612a8a8 1181
15c4dc5a 1182 case CMD_READER_LEGIC_RF:
1183 LegicRfReader(c->arg[0], c->arg[1]);
1184 break;
15c4dc5a 1185#endif
1186
1187#ifdef WITH_ISO14443b
15c4dc5a 1188 case CMD_READ_SRI512_TAG:
51d4f6f1 1189 ReadSTMemoryIso14443b(0x0F);
15c4dc5a 1190 break;
7e67e42f 1191 case CMD_READ_SRIX4K_TAG:
51d4f6f1 1192 ReadSTMemoryIso14443b(0x7F);
7e67e42f 1193 break;
132a0217 1194 case CMD_SNOOP_ISO_14443B:
51d4f6f1 1195 SnoopIso14443b();
7e67e42f 1196 break;
132a0217 1197 case CMD_SIMULATE_TAG_ISO_14443B:
51d4f6f1 1198 SimulateIso14443bTag();
7e67e42f 1199 break;
7cf3ef20 1200 case CMD_ISO_14443B_COMMAND:
1201 SendRawCommand14443B(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
1202 break;
15c4dc5a 1203#endif
1204
1205#ifdef WITH_ISO14443a
7e67e42f 1206 case CMD_SNOOP_ISO_14443a:
5cd9ec01 1207 SnoopIso14443a(c->arg[0]);
7e67e42f 1208 break;
15c4dc5a 1209 case CMD_READER_ISO_14443a:
902cb3c0 1210 ReaderIso14443a(c);
15c4dc5a 1211 break;
7e67e42f 1212 case CMD_SIMULATE_TAG_ISO_14443a:
28afbd2b 1213 SimulateIso14443aTag(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes); // ## Simulate iso14443a tag - pass tag type & UID
7e67e42f 1214 break;
3fe4ff4f 1215
5acd09bd 1216 case CMD_EPA_PACE_COLLECT_NONCE:
902cb3c0 1217 EPA_PACE_Collect_Nonce(c);
5acd09bd 1218 break;
3bb07d96
FM
1219 case CMD_EPA_PACE_REPLAY:
1220 EPA_PACE_Replay(c);
1221 break;
7e67e42f 1222
15c4dc5a 1223 case CMD_READER_MIFARE:
f168b263 1224 ReaderMifare(c->arg[0]);
15c4dc5a 1225 break;
20f9a2a1
M
1226 case CMD_MIFARE_READBL:
1227 MifareReadBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1228 break;
981bd429 1229 case CMD_MIFAREU_READBL:
f168b263 1230 MifareUReadBlock(c->arg[0],c->arg[1], c->d.asBytes);
981bd429 1231 break;
8258f409 1232 case CMD_MIFAREUC_AUTH:
1233 MifareUC_Auth(c->arg[0],c->d.asBytes);
a631936e 1234 break;
981bd429 1235 case CMD_MIFAREU_READCARD:
75377d29 1236 MifareUReadCard(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
117d9ec2 1237 break;
f168b263 1238 case CMD_MIFAREUC_SETPWD:
1239 MifareUSetPwd(c->arg[0], c->d.asBytes);
1240 break;
20f9a2a1
M
1241 case CMD_MIFARE_READSC:
1242 MifareReadSector(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1243 break;
1244 case CMD_MIFARE_WRITEBL:
1245 MifareWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1246 break;
0b4efbde 1247 case CMD_MIFARE_PERSONALIZE_UID:
1248 MifarePersonalizeUID(c->arg[0], c->arg[1], c->d.asBytes);
1249 break;
4973f23d 1250 //case CMD_MIFAREU_WRITEBL_COMPAT:
1251 //MifareUWriteBlockCompat(c->arg[0], c->d.asBytes);
1252 //break;
981bd429 1253 case CMD_MIFAREU_WRITEBL:
4973f23d 1254 MifareUWriteBlock(c->arg[0], c->arg[1], c->d.asBytes);
f168b263 1255 break;
c48c4d78 1256 case CMD_MIFARE_ACQUIRE_ENCRYPTED_NONCES:
1257 MifareAcquireEncryptedNonces(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1258 break;
20f9a2a1
M
1259 case CMD_MIFARE_NESTED:
1260 MifareNested(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
f397b5cc
M
1261 break;
1262 case CMD_MIFARE_CHKKEYS:
1263 MifareChkKeys(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
20f9a2a1
M
1264 break;
1265 case CMD_SIMULATE_MIFARE_CARD:
a8561e35 1266 MifareSim(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
20f9a2a1 1267 break;
8556b852
M
1268
1269 // emulator
1270 case CMD_MIFARE_SET_DBGMODE:
1271 MifareSetDbgLvl(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1272 break;
1273 case CMD_MIFARE_EML_MEMCLR:
1274 MifareEMemClr(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1275 break;
1276 case CMD_MIFARE_EML_MEMSET:
1277 MifareEMemSet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1278 break;
1279 case CMD_MIFARE_EML_MEMGET:
1280 MifareEMemGet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1281 break;
1282 case CMD_MIFARE_EML_CARDLOAD:
1283 MifareECardLoad(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
0675f200
M
1284 break;
1285
1286 // Work with "magic Chinese" card
3a05a1e7
OM
1287 case CMD_MIFARE_CWIPE:
1288 MifareCWipe(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1289 break;
3fe4ff4f 1290 case CMD_MIFARE_CSETBLOCK:
0675f200 1291 MifareCSetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
545a1f38 1292 break;
3fe4ff4f 1293 case CMD_MIFARE_CGETBLOCK:
545a1f38 1294 MifareCGetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
8556b852 1295 break;
3fe4ff4f 1296 case CMD_MIFARE_CIDENT:
1297 MifareCIdent();
1298 break;
b62a5a84
M
1299
1300 // mifare sniffer
1301 case CMD_MIFARE_SNIFFER:
5cd9ec01 1302 SniffMifare(c->arg[0]);
b62a5a84 1303 break;
a631936e 1304
20f9a2a1
M
1305#endif
1306
7e67e42f 1307#ifdef WITH_ICLASS
cee5a30d 1308 // Makes use of ISO14443a FPGA Firmware
1309 case CMD_SNOOP_ICLASS:
1310 SnoopIClass();
1311 break;
1e262141 1312 case CMD_SIMULATE_TAG_ICLASS:
ff7bb4ef 1313 SimulateIClass(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1e262141 1314 break;
1315 case CMD_READER_ICLASS:
1316 ReaderIClass(c->arg[0]);
1317 break;
c3963755 1318 case CMD_READER_ICLASS_REPLAY:
aa53efc3 1319 ReaderIClass_Replay(c->arg[0], c->d.asBytes);
c3963755 1320 break;
aa53efc3 1321 case CMD_ICLASS_EML_MEMSET:
e80aeb96
MHS
1322 emlSet(c->d.asBytes,c->arg[0], c->arg[1]);
1323 break;
aa53efc3 1324 case CMD_ICLASS_WRITEBLOCK:
3ac22ee1 1325 iClass_WriteBlock(c->arg[0], c->d.asBytes);
1326 break;
aa53efc3 1327 case CMD_ICLASS_READBLOCK:
3ac22ee1 1328 iClass_ReadBlk(c->arg[0]);
aa53efc3 1329 break;
ece38ef3 1330 case CMD_ICLASS_CHECK:
1331 iClass_Check(c->d.asBytes);
1332 break;
1333 case CMD_ICLASS_READCHECK:
1334 iClass_Readcheck(c->arg[0], c->arg[1]);
aa53efc3 1335 break;
1336 case CMD_ICLASS_DUMP:
3ac22ee1 1337 iClass_Dump(c->arg[0], c->arg[1]);
aa53efc3 1338 break;
1339 case CMD_ICLASS_CLONE:
3ac22ee1 1340 iClass_Clone(c->arg[0], c->arg[1], c->d.asBytes);
aa53efc3 1341 break;
cee5a30d 1342#endif
fc52fbd4 1343
0472d76d 1344#ifdef WITH_HFSNOOP
1345 case CMD_HF_SNIFFER:
1346 HfSnoop(c->arg[0], c->arg[1]);
1347 break;
fc52fbd4 1348 case CMD_HF_PLOT:
1349 HfPlot();
1350 break;
0472d76d 1351#endif
fc52fbd4 1352
43591e64 1353#ifdef WITH_SMARTCARD
1354 case CMD_SMART_ATR: {
1355 SmartCardAtr();
1356 break;
1357 }
1358 case CMD_SMART_SETCLOCK:{
1359 SmartCardSetClock(c->arg[0]);
1360 break;
1361 }
1362 case CMD_SMART_RAW: {
1363 SmartCardRaw(c->arg[0], c->arg[1], c->d.asBytes);
1364 break;
1365 }
1366 case CMD_SMART_UPLOAD: {
1367 // upload file from client
1368 uint8_t *mem = BigBuf_get_addr();
1369 memcpy( mem + c->arg[0], c->d.asBytes, USB_CMD_DATA_SIZE);
1370 cmd_send(CMD_ACK,1,0,0,0,0);
1371 break;
1372 }
1373 case CMD_SMART_UPGRADE: {
1374 SmartCardUpgrade(c->arg[0]);
1375 break;
1376 }
1377#endif
cee5a30d 1378
7e67e42f 1379 case CMD_BUFF_CLEAR:
117d9ec2 1380 BigBuf_Clear();
15c4dc5a 1381 break;
15c4dc5a 1382
1383 case CMD_MEASURE_ANTENNA_TUNING:
fdcfbdcc 1384 MeasureAntennaTuning(c->arg[0]);
15c4dc5a 1385 break;
1386
1387 case CMD_MEASURE_ANTENNA_TUNING_HF:
1388 MeasureAntennaTuningHf();
1389 break;
1390
1391 case CMD_LISTEN_READER_FIELD:
1392 ListenReaderField(c->arg[0]);
1393 break;
1394
15c4dc5a 1395 case CMD_FPGA_MAJOR_MODE_OFF: // ## FPGA Control
1396 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
1397 SpinDelay(200);
1398 LED_D_OFF(); // LED D indicates field ON or OFF
1399 break;
1400
1c611bbd 1401 case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K:
1c611bbd 1402 LED_B_ON();
117d9ec2 1403 uint8_t *BigBuf = BigBuf_get_addr();
1c611bbd 1404 for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
1405 size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
3000dc4e 1406 cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,BigBuf_get_traceLen(),BigBuf+c->arg[0]+i,len);
1c611bbd 1407 }
1408 // Trigger a finish downloading signal with an ACK frame
3000dc4e 1409 cmd_send(CMD_ACK,1,0,BigBuf_get_traceLen(),getSamplingConfig(),sizeof(sample_config));
d3b1f4e4 1410 LED_B_OFF();
1c611bbd 1411 break;
15c4dc5a 1412
1413 case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
8c8317a5 1414 // iceman; since changing fpga_bitstreams clears bigbuff, Its better to call it before.
1415 // to be able to use this one for uploading data to device
1416 // arg1 = 0 upload for LF usage
1417 // 1 upload for HF usage
1418 if (c->arg[1] == 0)
1419 FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
1420 else
1421 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
1422
117d9ec2 1423 uint8_t *b = BigBuf_get_addr();
3fe4ff4f 1424 memcpy(b+c->arg[0], c->d.asBytes, USB_CMD_DATA_SIZE);
1c611bbd 1425 cmd_send(CMD_ACK,0,0,0,0,0);
1426 break;
1427 }
15c4dc5a 1428 case CMD_READ_MEM:
1429 ReadMem(c->arg[0]);
1430 break;
1431
1432 case CMD_SET_LF_DIVISOR:
8c8317a5 1433 FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
15c4dc5a 1434 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, c->arg[0]);
1435 break;
1436
1437 case CMD_SET_ADC_MUX:
1438 switch(c->arg[0]) {
1439 case 0: SetAdcMuxFor(GPIO_MUXSEL_LOPKD); break;
1440 case 1: SetAdcMuxFor(GPIO_MUXSEL_LORAW); break;
1441 case 2: SetAdcMuxFor(GPIO_MUXSEL_HIPKD); break;
1442 case 3: SetAdcMuxFor(GPIO_MUXSEL_HIRAW); break;
1443 }
1444 break;
1445
1446 case CMD_VERSION:
1447 SendVersion();
1448 break;
c89274cc 1449 case CMD_STATUS:
67b7d6fa 1450 SendStatus();
c89274cc
CY
1451 break;
1452 case CMD_PING:
1453 cmd_send(CMD_ACK,0,0,0,0,0);
1454 break;
15c4dc5a 1455#ifdef WITH_LCD
1456 case CMD_LCD_RESET:
1457 LCDReset();
1458 break;
1459 case CMD_LCD:
1460 LCDSend(c->arg[0]);
1461 break;
1462#endif
1463 case CMD_SETUP_WRITE:
1464 case CMD_FINISH_WRITE:
1c611bbd 1465 case CMD_HARDWARE_RESET:
1466 usb_disable();
15c4dc5a 1467 SpinDelay(1000);
1468 SpinDelay(1000);
1469 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
1470 for(;;) {
1471 // We're going to reset, and the bootrom will take control.
1472 }
1c611bbd 1473 break;
15c4dc5a 1474
1c611bbd 1475 case CMD_START_FLASH:
15c4dc5a 1476 if(common_area.flags.bootrom_present) {
1477 common_area.command = COMMON_AREA_COMMAND_ENTER_FLASH_MODE;
1478 }
1c611bbd 1479 usb_disable();
15c4dc5a 1480 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
1481 for(;;);
1c611bbd 1482 break;
e30c654b 1483
15c4dc5a 1484 case CMD_DEVICE_INFO: {
902cb3c0 1485 uint32_t dev_info = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS;
1486 if(common_area.flags.bootrom_present) dev_info |= DEVICE_INFO_FLAG_BOOTROM_PRESENT;
1c611bbd 1487 cmd_send(CMD_DEVICE_INFO,dev_info,0,0,0,0);
1488 break;
1489 }
1490 default:
15c4dc5a 1491 Dbprintf("%s: 0x%04x","unknown command:",c->cmd);
1c611bbd 1492 break;
15c4dc5a 1493 }
1494}
1495
1496void __attribute__((noreturn)) AppMain(void)
1497{
1498 SpinDelay(100);
9e8255d4 1499 clear_trace();
15c4dc5a 1500 if(common_area.magic != COMMON_AREA_MAGIC || common_area.version != 1) {
1501 /* Initialize common area */
1502 memset(&common_area, 0, sizeof(common_area));
1503 common_area.magic = COMMON_AREA_MAGIC;
1504 common_area.version = 1;
1505 }
1506 common_area.flags.osimage_present = 1;
1507
3d057cfb
SG
1508 LEDsoff();
1509
3fe4ff4f 1510 // Init USB device
050aa18b 1511 usb_enable();
15c4dc5a 1512
1513 // The FPGA gets its clock from us from PCK0 output, so set that up.
1514 AT91C_BASE_PIOA->PIO_BSR = GPIO_PCK0;
1515 AT91C_BASE_PIOA->PIO_PDR = GPIO_PCK0;
1516 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_PCK0;
1517 // PCK0 is PLL clock / 4 = 96Mhz / 4 = 24Mhz
1518 AT91C_BASE_PMC->PMC_PCKR[0] = AT91C_PMC_CSS_PLL_CLK |
0472d76d 1519 AT91C_PMC_PRES_CLK_4; // 4 for 24Mhz pck0, 2 for 48 MHZ pck0
15c4dc5a 1520 AT91C_BASE_PIOA->PIO_OER = GPIO_PCK0;
1521
1522 // Reset SPI
1523 AT91C_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
1524 // Reset SSC
1525 AT91C_BASE_SSC->SSC_CR = AT91C_SSC_SWRST;
1526
1527 // Load the FPGA image, which we have stored in our flash.
7cc204bf 1528 // (the HF version by default)
1529 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
15c4dc5a 1530
9ca155ba 1531 StartTickCount();
902cb3c0 1532
15c4dc5a 1533#ifdef WITH_LCD
15c4dc5a 1534 LCDInit();
15c4dc5a 1535#endif
1536
902cb3c0 1537 byte_t rx[sizeof(UsbCommand)];
1538 size_t rx_len;
1539
15c4dc5a 1540 for(;;) {
902cb3c0 1541 if (usb_poll()) {
1542 rx_len = usb_read(rx,sizeof(UsbCommand));
1543 if (rx_len) {
1544 UsbPacketReceived(rx,rx_len);
1545 }
1546 }
15c4dc5a 1547 WDT_HIT();
1548
a2937cea 1549#ifdef WITH_LF_StandAlone
e46fe044 1550#ifndef WITH_ISO14443a_StandAlone
15c4dc5a 1551 if (BUTTON_HELD(1000) > 0)
1552 SamyRun();
e46fe044
CY
1553#endif
1554#endif
1555#ifdef WITH_ISO14443a
1556#ifdef WITH_ISO14443a_StandAlone
1557 if (BUTTON_HELD(1000) > 0)
1558 StandAloneMode14a();
1559#endif
15c4dc5a 1560#endif
1561 }
1562}
Impressum, Datenschutz