]> git.zerfleddert.de Git - proxmark3-svn/blob - armsrc/appmain.c
projects / proxmark3-svn / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Introducing a stand-alone mode for working with NFC (ISO14443a) tag UIDs.
[proxmark3-svn] / armsrc / appmain.c
1 //-----------------------------------------------------------------------------
2 // Jonathan Westhues, Mar 2006
3 // Edits by Gerhard de Koning Gans, Sep 2007 (##)
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.
11 //-----------------------------------------------------------------------------
12
13 #include "usb_cdc.h"
14 #include "cmd.h"
15
16 #include "proxmark3.h"
17 #include "apps.h"
18 #include "util.h"
19 #include "printf.h"
20 #include "string.h"
21
22 #include <stdarg.h>
23
24 #include "legicrf.h"
25 #include <hitag2.h>
26 #include "lfsampling.h"
27 #include "BigBuf.h"
28 #ifdef WITH_LCD
29 #include "LCD.h"
30 #endif
31
32 // Craig Young - 14a stand-alone code
33 #ifdef WITH_ISO14443a_StandAlone
34 #include "iso14443a.h"
35 #endif
36
37 #define abs(x) ( ((x)<0) ? -(x) : (x) )
38
39 //=============================================================================
40 // A buffer where we can queue things up to be sent through the FPGA, for
41 // any purpose (fake tag, as reader, whatever). We go MSB first, since that
42 // is the order in which they go out on the wire.
43 //=============================================================================
44
45 #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
46 uint8_t ToSend[TOSEND_BUFFER_SIZE];
47 int ToSendMax;
48 static int ToSendBit;
49 struct common_area common_area __attribute__((section(".commonarea")));
50
51 void ToSendReset(void)
52 {
53 ToSendMax = -1;
54 ToSendBit = 8;
55 }
56
57 void ToSendStuffBit(int b)
58 {
59 if(ToSendBit >= 8) {
60 ToSendMax++;
61 ToSend[ToSendMax] = 0;
62 ToSendBit = 0;
63 }
64
65 if(b) {
66 ToSend[ToSendMax] |= (1 << (7 - ToSendBit));
67 }
68
69 ToSendBit++;
70
71 if(ToSendMax >= sizeof(ToSend)) {
72 ToSendBit = 0;
73 DbpString("ToSendStuffBit overflowed!");
74 }
75 }
76
77 //=============================================================================
78 // Debug print functions, to go out over USB, to the usual PC-side client.
79 //=============================================================================
80
81 void DbpString(char *str)
82 {
83 byte_t len = strlen(str);
84 cmd_send(CMD_DEBUG_PRINT_STRING,len,0,0,(byte_t*)str,len);
85 }
86
87 #if 0
88 void DbpIntegers(int x1, int x2, int x3)
89 {
90 cmd_send(CMD_DEBUG_PRINT_INTEGERS,x1,x2,x3,0,0);
91 }
92 #endif
93
94 void Dbprintf(const char *fmt, ...) {
95 // should probably limit size here; oh well, let's just use a big buffer
96 char output_string[128];
97 va_list ap;
98
99 va_start(ap, fmt);
100 kvsprintf(fmt, output_string, 10, ap);
101 va_end(ap);
102
103 DbpString(output_string);
104 }
105
106 // prints HEX & ASCII
107 void Dbhexdump(int len, uint8_t *d, bool bAsci) {
108 int l=0,i;
109 char ascii[9];
110
111 while (len>0) {
112 if (len>8) l=8;
113 else l=len;
114
115 memcpy(ascii,d,l);
116 ascii[l]=0;
117
118 // filter safe ascii
119 for (i=0;i<l;i++)
120 if (ascii[i]<32 || ascii[i]>126) ascii[i]='.';
121
122 if (bAsci) {
123 Dbprintf("%-8s %*D",ascii,l,d," ");
124 } else {
125 Dbprintf("%*D",l,d," ");
126 }
127
128 len-=8;
129 d+=8;
130 }
131 }
132
133 //-----------------------------------------------------------------------------
134 // Read an ADC channel and block till it completes, then return the result
135 // in ADC units (0 to 1023). Also a routine to average 32 samples and
136 // return that.
137 //-----------------------------------------------------------------------------
138 static int ReadAdc(int ch)
139 {
140 uint32_t d;
141
142 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
143 AT91C_BASE_ADC->ADC_MR =
144 ADC_MODE_PRESCALE(63 /* was 32 */) | // ADC_CLK = MCK / ((63+1) * 2) = 48MHz / 128 = 375kHz
145 ADC_MODE_STARTUP_TIME(1 /* was 16 */) | // Startup Time = (1+1) * 8 / ADC_CLK = 16 / 375kHz = 42,7us Note: must be > 20us
146 ADC_MODE_SAMPLE_HOLD_TIME(15 /* was 8 */); // Sample & Hold Time SHTIM = 15 / ADC_CLK = 15 / 375kHz = 40us
147
148 // Note: ADC_MODE_PRESCALE and ADC_MODE_SAMPLE_HOLD_TIME are set to the maximum allowed value.
149 // Both AMPL_LO and AMPL_HI are very high impedance (10MOhm) outputs, the input capacitance of the ADC is 12pF (typical). This results in a time constant
150 // of RC = 10MOhm * 12pF = 120us. Even after the maximum configurable sample&hold time of 40us the input capacitor will not be fully charged.
151 //
152 // The maths are:
153 // 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
154 //
155 // v_cap = v_in * (1 - exp(-RC/SHTIM)) = v_in * (1 - exp(-3)) = v_in * 0,95 (i.e. an error of 5%)
156 //
157 // Note: with the "historic" values in the comments above, the error was 34% !!!
158
159 AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ch);
160
161 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
162
163 while(!(AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ch)))
164 ;
165 d = AT91C_BASE_ADC->ADC_CDR[ch];
166
167 return d;
168 }
169
170 int AvgAdc(int ch) // was static - merlok
171 {
172 int i;
173 int a = 0;
174
175 for(i = 0; i < 32; i++) {
176 a += ReadAdc(ch);
177 }
178
179 return (a + 15) >> 5;
180 }
181
182 void MeasureAntennaTuning(void)
183 {
184 uint8_t LF_Results[256];
185 int i, adcval = 0, peak = 0, peakv = 0, peakf = 0; //ptr = 0
186 int vLf125 = 0, vLf134 = 0, vHf = 0; // in mV
187
188 LED_B_ON();
189
190 /*
191 * Sweeps the useful LF range of the proxmark from
192 * 46.8kHz (divisor=255) to 600kHz (divisor=19) and
193 * read the voltage in the antenna, the result left
194 * in the buffer is a graph which should clearly show
195 * the resonating frequency of your LF antenna
196 * ( hopefully around 95 if it is tuned to 125kHz!)
197 */
198
199 FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
200 FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
201 for (i=255; i>=19; i--) {
202 WDT_HIT();
203 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, i);
204 SpinDelay(20);
205 adcval = ((MAX_ADC_LF_VOLTAGE * AvgAdc(ADC_CHAN_LF)) >> 10);
206 if (i==95) vLf125 = adcval; // voltage at 125Khz
207 if (i==89) vLf134 = adcval; // voltage at 134Khz
208
209 LF_Results[i] = adcval>>8; // scale int to fit in byte for graphing purposes
210 if(LF_Results[i] > peak) {
211 peakv = adcval;
212 peak = LF_Results[i];
213 peakf = i;
214 //ptr = i;
215 }
216 }
217
218 for (i=18; i >= 0; i--) LF_Results[i] = 0;
219
220 LED_A_ON();
221 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
222 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
223 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
224 SpinDelay(20);
225 vHf = (MAX_ADC_HF_VOLTAGE * AvgAdc(ADC_CHAN_HF)) >> 10;
226
227 cmd_send(CMD_MEASURED_ANTENNA_TUNING, vLf125 | (vLf134<<16), vHf, peakf | (peakv<<16), LF_Results, 256);
228 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
229 LED_A_OFF();
230 LED_B_OFF();
231 return;
232 }
233
234 void MeasureAntennaTuningHf(void)
235 {
236 int vHf = 0; // in mV
237
238 DbpString("Measuring HF antenna, press button to exit");
239
240 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
241 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
242 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
243
244 for (;;) {
245 SpinDelay(20);
246 vHf = (MAX_ADC_HF_VOLTAGE * AvgAdc(ADC_CHAN_HF)) >> 10;
247
248 Dbprintf("%d mV",vHf);
249 if (BUTTON_PRESS()) break;
250 }
251 DbpString("cancelled");
252
253 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
254
255 }
256
257
258 void ReadMem(int addr)
259 {
260 const uint8_t *data = ((uint8_t *)addr);
261
262 Dbprintf("%x: %02x %02x %02x %02x %02x %02x %02x %02x",
263 addr, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
264 }
265
266 /* osimage version information is linked in */
267 extern struct version_information version_information;
268 /* bootrom version information is pointed to from _bootphase1_version_pointer */
269 extern char *_bootphase1_version_pointer, _flash_start, _flash_end, _bootrom_start, _bootrom_end, __data_src_start__;
270 void SendVersion(void)
271 {
272 char temp[USB_CMD_DATA_SIZE]; /* Limited data payload in USB packets */
273 char VersionString[USB_CMD_DATA_SIZE] = { '\0' };
274
275 /* Try to find the bootrom version information. Expect to find a pointer at
276 * symbol _bootphase1_version_pointer, perform slight sanity checks on the
277 * pointer, then use it.
278 */
279 char *bootrom_version = *(char**)&_bootphase1_version_pointer;
280 if( bootrom_version < &_flash_start || bootrom_version >= &_flash_end ) {
281 strcat(VersionString, "bootrom version information appears invalid\n");
282 } else {
283 FormatVersionInformation(temp, sizeof(temp), "bootrom: ", bootrom_version);
284 strncat(VersionString, temp, sizeof(VersionString) - strlen(VersionString) - 1);
285 }
286
287 FormatVersionInformation(temp, sizeof(temp), "os: ", &version_information);
288 strncat(VersionString, temp, sizeof(VersionString) - strlen(VersionString) - 1);
289
290 FpgaGatherVersion(FPGA_BITSTREAM_LF, temp, sizeof(temp));
291 strncat(VersionString, temp, sizeof(VersionString) - strlen(VersionString) - 1);
292 FpgaGatherVersion(FPGA_BITSTREAM_HF, temp, sizeof(temp));
293 strncat(VersionString, temp, sizeof(VersionString) - strlen(VersionString) - 1);
294
295 // Send Chip ID and used flash memory
296 uint32_t text_and_rodata_section_size = (uint32_t)&__data_src_start__ - (uint32_t)&_flash_start;
297 uint32_t compressed_data_section_size = common_area.arg1;
298 cmd_send(CMD_ACK, *(AT91C_DBGU_CIDR), text_and_rodata_section_size + compressed_data_section_size, 0, VersionString, strlen(VersionString));
299 }
300
301 #ifdef WITH_LF
302 #ifndef WITH_ISO14443a_StandAlone
303 // samy's sniff and repeat routine
304 void SamyRun()
305 {
306 DbpString("Stand-alone mode! No PC necessary.");
307 FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
308
309 // 3 possible options? no just 2 for now
310 #define OPTS 2
311
312 int high[OPTS], low[OPTS];
313
314 // Oooh pretty -- notify user we're in elite samy mode now
315 LED(LED_RED, 200);
316 LED(LED_ORANGE, 200);
317 LED(LED_GREEN, 200);
318 LED(LED_ORANGE, 200);
319 LED(LED_RED, 200);
320 LED(LED_ORANGE, 200);
321 LED(LED_GREEN, 200);
322 LED(LED_ORANGE, 200);
323 LED(LED_RED, 200);
324
325 int selected = 0;
326 int playing = 0;
327 int cardRead = 0;
328
329 // Turn on selected LED
330 LED(selected + 1, 0);
331
332 for (;;)
333 {
334 usb_poll();
335 WDT_HIT();
336
337 // Was our button held down or pressed?
338 int button_pressed = BUTTON_HELD(1000);
339 SpinDelay(300);
340
341 // Button was held for a second, begin recording
342 if (button_pressed > 0 && cardRead == 0)
343 {
344 LEDsoff();
345 LED(selected + 1, 0);
346 LED(LED_RED2, 0);
347
348 // record
349 DbpString("Starting recording");
350
351 // wait for button to be released
352 while(BUTTON_PRESS())
353 WDT_HIT();
354
355 /* need this delay to prevent catching some weird data */
356 SpinDelay(500);
357
358 CmdHIDdemodFSK(1, &high[selected], &low[selected], 0);
359 Dbprintf("Recorded %x %x %x", selected, high[selected], low[selected]);
360
361 LEDsoff();
362 LED(selected + 1, 0);
363 // Finished recording
364
365 // If we were previously playing, set playing off
366 // so next button push begins playing what we recorded
367 playing = 0;
368
369 cardRead = 1;
370
371 }
372
373 else if (button_pressed > 0 && cardRead == 1)
374 {
375 LEDsoff();
376 LED(selected + 1, 0);
377 LED(LED_ORANGE, 0);
378
379 // record
380 Dbprintf("Cloning %x %x %x", selected, high[selected], low[selected]);
381
382 // wait for button to be released
383 while(BUTTON_PRESS())
384 WDT_HIT();
385
386 /* need this delay to prevent catching some weird data */
387 SpinDelay(500);
388
389 CopyHIDtoT55x7(high[selected], low[selected], 0, 0);
390 Dbprintf("Cloned %x %x %x", selected, high[selected], low[selected]);
391
392 LEDsoff();
393 LED(selected + 1, 0);
394 // Finished recording
395
396 // If we were previously playing, set playing off
397 // so next button push begins playing what we recorded
398 playing = 0;
399
400 cardRead = 0;
401
402 }
403
404 // Change where to record (or begin playing)
405 else if (button_pressed)
406 {
407 // Next option if we were previously playing
408 if (playing)
409 selected = (selected + 1) % OPTS;
410 playing = !playing;
411
412 LEDsoff();
413 LED(selected + 1, 0);
414
415 // Begin transmitting
416 if (playing)
417 {
418 LED(LED_GREEN, 0);
419 DbpString("Playing");
420 // wait for button to be released
421 while(BUTTON_PRESS())
422 WDT_HIT();
423 Dbprintf("%x %x %x", selected, high[selected], low[selected]);
424 CmdHIDsimTAG(high[selected], low[selected], 0);
425 DbpString("Done playing");
426 if (BUTTON_HELD(1000) > 0)
427 {
428 DbpString("Exiting");
429 LEDsoff();
430 return;
431 }
432
433 /* We pressed a button so ignore it here with a delay */
434 SpinDelay(300);
435
436 // when done, we're done playing, move to next option
437 selected = (selected + 1) % OPTS;
438 playing = !playing;
439 LEDsoff();
440 LED(selected + 1, 0);
441 }
442 else
443 while(BUTTON_PRESS())
444 WDT_HIT();
445 }
446 }
447 }
448 #endif
449 #endif
450 #ifdef WITH_ISO14443a
451 #ifdef WITH_ISO14443a_StandAlone
452 void StandAloneMode14a()
453 {
454 DbpString("Stand-alone mode! No PC necessary.");
455 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
456
457 // 3 possible options? no just 1 for now
458 #undef OPTS
459 #define OPTS 2
460 // Oooh pretty -- notify user we're in elite samy mode now
461 LED(LED_RED, 200);
462 LED(LED_ORANGE, 200);
463 LED(LED_GREEN, 200);
464 LED(LED_ORANGE, 200);
465 LED(LED_RED, 200);
466 LED(LED_ORANGE, 200);
467 LED(LED_GREEN, 200);
468 LED(LED_ORANGE, 200);
469 LED(LED_RED, 200);
470
471 int selected = 0;
472 int playing = 0;
473 int cardRead[OPTS] = {0};
474 uint8_t readUID[10] = {0};
475 int uid_1st[OPTS]={0};
476 int uid_2nd[OPTS]={0};
477
478 LED(selected + 1, 0);
479
480 for (;;)
481 {
482 usb_poll();
483 WDT_HIT();
484
485 // Was our button held down or pressed?
486 int button_pressed = BUTTON_HELD(1000);
487
488 SpinDelay(300);
489
490 // Button was held for a second, begin recording
491 if (button_pressed > 0 && cardRead[selected] == 0)
492 {
493 LEDsoff();
494 LED(selected + 1, 0);
495 LED(LED_RED2, 0);
496
497 // record
498 Dbprintf("Enabling iso14443a reader mode for [Bank: %u]...", selected);
499
500 // wait for button to be released
501 while(BUTTON_PRESS())
502 WDT_HIT();
503 /* need this delay to prevent catching some weird data */
504 SpinDelay(500);
505 /* Code for reading from 14a tag */
506 uint8_t uid[10] ={0};
507 uint32_t cuid;
508 iso14443a_setup(FPGA_HF_ISO14443A_READER_MOD);
509
510 for ( ; ; )
511 {
512 if (!iso14443a_select_card(uid, NULL, &cuid))
513 continue;
514 else
515 {
516 Dbprintf("Read UID:"); Dbhexdump(10,uid,0);
517 memcpy(readUID,uid,10*sizeof(uint8_t));
518 uint8_t *dst = (uint8_t *)&uid_1st[selected];
519 // Set UID byte order
520 for (int i=0; i<4; i++)
521 dst[i] = uid[3-i];
522 dst = (uint8_t *)&uid_2nd[selected];
523 for (int i=0; i<4; i++)
524 dst[i] = uid[7-i];
525 break;
526 }
527 }
528 LEDsoff();
529 LED(LED_GREEN, 200);
530 LED(LED_ORANGE, 200);
531 LED(LED_GREEN, 200);
532 LED(LED_ORANGE, 200);
533
534 LEDsoff();
535 LED(selected + 1, 0);
536 // Finished recording
537
538 // If we were previously playing, set playing off
539 // so next button push begins playing what we recorded
540 playing = 0;
541
542 cardRead[selected] = 1;
543
544 }
545 /* MF UID clone */
546 else if (button_pressed > 0 && cardRead[selected] == 1)
547 {
548 LEDsoff();
549 LED(selected + 1, 0);
550 LED(LED_ORANGE, 250);
551
552
553 // record
554 Dbprintf("Preparing to Clone card [Bank: %x]; uid: %08x", selected, uid_1st[selected]);
555
556 // wait for button to be released
557 while(BUTTON_PRESS())
558 {
559 // Delay cloning until card is in place
560 WDT_HIT();
561 }
562 Dbprintf("Starting clone. [Bank: %u]", selected);
563 // need this delay to prevent catching some weird data
564 SpinDelay(500);
565 // Begin clone function here:
566 /* Example from client/mifarehost.c for commanding a block write for "magic Chinese" cards:
567 UsbCommand c = {CMD_MIFARE_CSETBLOCK, {wantWipe, params & (0xFE | (uid == NULL ? 0:1)), blockNo}};
568 memcpy(c.d.asBytes, data, 16);
569 SendCommand(&c);
570
571 Block read is similar:
572 UsbCommand c = {CMD_MIFARE_CGETBLOCK, {params, 0, blockNo}};
573 We need to imitate that call with blockNo 0 to set a uid.
574
575 The get and set commands are handled in this file:
576 // Work with "magic Chinese" card
577 case CMD_MIFARE_CSETBLOCK:
578 MifareCSetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
579 break;
580 case CMD_MIFARE_CGETBLOCK:
581 MifareCGetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
582 //
583 break;
584
585 mfCSetUID provides example logic for UID set workflow:
586 -Read block0 from card in field with MifareCGetBlock()
587 -Configure new values without replacing reserved bytes
588 memcpy(block0, uid, 4); // Copy UID bytes from byte array
589 // Mifare UID BCC
590 block0[4] = block0[0]^block0[1]^block0[2]^block0[3]; // BCC on byte 5
591 Bytes 5-7 are reserved SAK and ATQA for mifare classic
592 -Use mfCSetBlock(0, block0, oldUID, wantWipe, CSETBLOCK_SINGLE_OPER) to write it
593 */
594 uint8_t oldBlock0[16] = {0}, newBlock0[16] = {0}, testBlock0[16] = {0};
595 // arg0 = Flags == CSETBLOCK_SINGLE_OPER=0x1F, arg1=returnSlot, arg2=blockNo
596 MifareCGetBlock(0x1F, 1, 0, oldBlock0);
597 Dbprintf("UID from target tag: %02X%02X%02X%02X", oldBlock0[0],oldBlock0[1],oldBlock0[2],oldBlock0[3]);
598 memcpy(newBlock0,oldBlock0,16);
599 // Copy uid_1st for bank (2nd is for longer UIDs not supported if classic)
600 newBlock0[0] = uid_1st[selected]>>24;
601 newBlock0[1] = 0xFF & (uid_1st[selected]>>16);
602 newBlock0[2] = 0xFF & (uid_1st[selected]>>8);
603 newBlock0[3] = 0xFF & (uid_1st[selected]);
604 newBlock0[4] = newBlock0[0]^newBlock0[1]^newBlock0[2]^newBlock0[3];
605 // arg0 = needWipe, arg1 = workFlags, arg2 = blockNo, datain
606 MifareCSetBlock(0, 0xFF,0, newBlock0);
607 MifareCGetBlock(0x1F, 1, 0, testBlock0);
608 if (memcmp(testBlock0,newBlock0,16)==0)
609 {
610 DbpString("Cloned successfull!");
611 cardRead[selected] = 0; // Only if the card was cloned successfully should we clear it
612 }
613 LEDsoff();
614 LED(selected + 1, 0);
615 // Finished recording
616
617 // If we were previously playing, set playing off
618 // so next button push begins playing what we recorded
619 playing = 0;
620
621 }
622 // Change where to record (or begin playing)
623 else if (button_pressed && cardRead[selected])
624 {
625 // Next option if we were previously playing
626 if (playing)
627 selected = (selected + 1) % OPTS;
628 playing = !playing;
629
630 LEDsoff();
631 LED(selected + 1, 0);
632
633 // Begin transmitting
634 if (playing)
635 {
636 LED(LED_GREEN, 0);
637 DbpString("Playing");
638 while (!BUTTON_HELD(500)) { // Loop simulating tag until the button is held a half-sec
639 Dbprintf("Simulating ISO14443a tag with uid[0]: %08x, uid[1]: %08x [Bank: %u]", uid_1st[selected],uid_2nd[selected],selected);
640 SimulateIso14443aTag(1,uid_1st[selected],uid_2nd[selected],NULL);
641 }
642 //cardRead[selected] = 1;
643 Dbprintf("Done playing [Bank: %u]",selected);
644
645 /* We pressed a button so ignore it here with a delay */
646 SpinDelay(300);
647
648 // when done, we're done playing, move to next option
649 selected = (selected + 1) % OPTS;
650 playing = !playing;
651 LEDsoff();
652 LED(selected + 1, 0);
653 }
654 else
655 while(BUTTON_PRESS())
656 WDT_HIT();
657 }
658 }
659 }
660 #endif
661 #endif
662 /*
663 OBJECTIVE
664 Listen and detect an external reader. Determine the best location
665 for the antenna.
666
667 INSTRUCTIONS:
668 Inside the ListenReaderField() function, there is two mode.
669 By default, when you call the function, you will enter mode 1.
670 If you press the PM3 button one time, you will enter mode 2.
671 If you press the PM3 button a second time, you will exit the function.
672
673 DESCRIPTION OF MODE 1:
674 This mode just listens for an external reader field and lights up green
675 for HF and/or red for LF. This is the original mode of the detectreader
676 function.
677
678 DESCRIPTION OF MODE 2:
679 This mode will visually represent, using the LEDs, the actual strength of the
680 current compared to the maximum current detected. Basically, once you know
681 what kind of external reader is present, it will help you spot the best location to place
682 your antenna. You will probably not get some good results if there is a LF and a HF reader
683 at the same place! :-)
684
685 LIGHT SCHEME USED:
686 */
687 static const char LIGHT_SCHEME[] = {
688 0x0, /* ---- | No field detected */
689 0x1, /* X--- | 14% of maximum current detected */
690 0x2, /* -X-- | 29% of maximum current detected */
691 0x4, /* --X- | 43% of maximum current detected */
692 0x8, /* ---X | 57% of maximum current detected */
693 0xC, /* --XX | 71% of maximum current detected */
694 0xE, /* -XXX | 86% of maximum current detected */
695 0xF, /* XXXX | 100% of maximum current detected */
696 };
697 static const int LIGHT_LEN = sizeof(LIGHT_SCHEME)/sizeof(LIGHT_SCHEME[0]);
698
699 void ListenReaderField(int limit)
700 {
701 int lf_av, lf_av_new, lf_baseline= 0, lf_max;
702 int hf_av, hf_av_new, hf_baseline= 0, hf_max;
703 int mode=1, display_val, display_max, i;
704
705 #define LF_ONLY 1
706 #define HF_ONLY 2
707 #define REPORT_CHANGE 10 // report new values only if they have changed at least by REPORT_CHANGE
708
709
710 // switch off FPGA - we don't want to measure our own signal
711 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
712 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
713
714 LEDsoff();
715
716 lf_av = lf_max = AvgAdc(ADC_CHAN_LF);
717
718 if(limit != HF_ONLY) {
719 Dbprintf("LF 125/134kHz Baseline: %dmV", (MAX_ADC_LF_VOLTAGE * lf_av) >> 10);
720 lf_baseline = lf_av;
721 }
722
723 hf_av = hf_max = AvgAdc(ADC_CHAN_HF);
724
725 if (limit != LF_ONLY) {
726 Dbprintf("HF 13.56MHz Baseline: %dmV", (MAX_ADC_HF_VOLTAGE * hf_av) >> 10);
727 hf_baseline = hf_av;
728 }
729
730 for(;;) {
731 if (BUTTON_PRESS()) {
732 SpinDelay(500);
733 switch (mode) {
734 case 1:
735 mode=2;
736 DbpString("Signal Strength Mode");
737 break;
738 case 2:
739 default:
740 DbpString("Stopped");
741 LEDsoff();
742 return;
743 break;
744 }
745 }
746 WDT_HIT();
747
748 if (limit != HF_ONLY) {
749 if(mode == 1) {
750 if (abs(lf_av - lf_baseline) > REPORT_CHANGE)
751 LED_D_ON();
752 else
753 LED_D_OFF();
754 }
755
756 lf_av_new = AvgAdc(ADC_CHAN_LF);
757 // see if there's a significant change
758 if(abs(lf_av - lf_av_new) > REPORT_CHANGE) {
759 Dbprintf("LF 125/134kHz Field Change: %5dmV", (MAX_ADC_LF_VOLTAGE * lf_av_new) >> 10);
760 lf_av = lf_av_new;
761 if (lf_av > lf_max)
762 lf_max = lf_av;
763 }
764 }
765
766 if (limit != LF_ONLY) {
767 if (mode == 1){
768 if (abs(hf_av - hf_baseline) > REPORT_CHANGE)
769 LED_B_ON();
770 else
771 LED_B_OFF();
772 }
773
774 hf_av_new = AvgAdc(ADC_CHAN_HF);
775 // see if there's a significant change
776 if(abs(hf_av - hf_av_new) > REPORT_CHANGE) {
777 Dbprintf("HF 13.56MHz Field Change: %5dmV", (MAX_ADC_HF_VOLTAGE * hf_av_new) >> 10);
778 hf_av = hf_av_new;
779 if (hf_av > hf_max)
780 hf_max = hf_av;
781 }
782 }
783
784 if(mode == 2) {
785 if (limit == LF_ONLY) {
786 display_val = lf_av;
787 display_max = lf_max;
788 } else if (limit == HF_ONLY) {
789 display_val = hf_av;
790 display_max = hf_max;
791 } else { /* Pick one at random */
792 if( (hf_max - hf_baseline) > (lf_max - lf_baseline) ) {
793 display_val = hf_av;
794 display_max = hf_max;
795 } else {
796 display_val = lf_av;
797 display_max = lf_max;
798 }
799 }
800 for (i=0; i<LIGHT_LEN; i++) {
801 if (display_val >= ((display_max/LIGHT_LEN)*i) && display_val <= ((display_max/LIGHT_LEN)*(i+1))) {
802 if (LIGHT_SCHEME[i] & 0x1) LED_C_ON(); else LED_C_OFF();
803 if (LIGHT_SCHEME[i] & 0x2) LED_A_ON(); else LED_A_OFF();
804 if (LIGHT_SCHEME[i] & 0x4) LED_B_ON(); else LED_B_OFF();
805 if (LIGHT_SCHEME[i] & 0x8) LED_D_ON(); else LED_D_OFF();
806 break;
807 }
808 }
809 }
810 }
811 }
812
813 void UsbPacketReceived(uint8_t *packet, int len)
814 {
815 UsbCommand *c = (UsbCommand *)packet;
816
817 // 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]);
818
819 switch(c->cmd) {
820 #ifdef WITH_LF
821 case CMD_SET_LF_SAMPLING_CONFIG:
822 setSamplingConfig((sample_config *) c->d.asBytes);
823 break;
824 case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
825 cmd_send(CMD_ACK,SampleLF(c->arg[0]),0,0,0,0);
826 break;
827 case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
828 ModThenAcquireRawAdcSamples125k(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
829 break;
830 case CMD_LF_SNOOP_RAW_ADC_SAMPLES:
831 cmd_send(CMD_ACK,SnoopLF(),0,0,0,0);
832 break;
833 case CMD_HID_DEMOD_FSK:
834 CmdHIDdemodFSK(c->arg[0], 0, 0, 1);
835 break;
836 case CMD_HID_SIM_TAG:
837 CmdHIDsimTAG(c->arg[0], c->arg[1], 1);
838 break;
839 case CMD_FSK_SIM_TAG:
840 CmdFSKsimTAG(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
841 break;
842 case CMD_ASK_SIM_TAG:
843 CmdASKsimTag(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
844 break;
845 case CMD_PSK_SIM_TAG:
846 CmdPSKsimTag(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
847 break;
848 case CMD_HID_CLONE_TAG:
849 CopyHIDtoT55x7(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
850 break;
851 case CMD_IO_DEMOD_FSK:
852 CmdIOdemodFSK(c->arg[0], 0, 0, 1);
853 break;
854 case CMD_IO_CLONE_TAG:
855 CopyIOtoT55x7(c->arg[0], c->arg[1], c->d.asBytes[0]);
856 break;
857 case CMD_EM410X_DEMOD:
858 CmdEM410xdemod(c->arg[0], 0, 0, 1);
859 break;
860 case CMD_EM410X_WRITE_TAG:
861 WriteEM410x(c->arg[0], c->arg[1], c->arg[2]);
862 break;
863 case CMD_READ_TI_TYPE:
864 ReadTItag();
865 break;
866 case CMD_WRITE_TI_TYPE:
867 WriteTItag(c->arg[0],c->arg[1],c->arg[2]);
868 break;
869 case CMD_SIMULATE_TAG_125K:
870 LED_A_ON();
871 SimulateTagLowFrequency(c->arg[0], c->arg[1], 1);
872 LED_A_OFF();
873 break;
874 case CMD_LF_SIMULATE_BIDIR:
875 SimulateTagLowFrequencyBidir(c->arg[0], c->arg[1]);
876 break;
877 case CMD_INDALA_CLONE_TAG:
878 CopyIndala64toT55x7(c->arg[0], c->arg[1]);
879 break;
880 case CMD_INDALA_CLONE_TAG_L:
881 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]);
882 break;
883 case CMD_T55XX_READ_BLOCK:
884 T55xxReadBlock(c->arg[1], c->arg[2],c->d.asBytes[0]);
885 break;
886 case CMD_T55XX_WRITE_BLOCK:
887 T55xxWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
888 break;
889 case CMD_T55XX_READ_TRACE:
890 T55xxReadTrace();
891 break;
892 case CMD_PCF7931_READ:
893 ReadPCF7931();
894 cmd_send(CMD_ACK,0,0,0,0,0);
895 break;
896 case CMD_EM4X_READ_WORD:
897 EM4xReadWord(c->arg[1], c->arg[2],c->d.asBytes[0]);
898 break;
899 case CMD_EM4X_WRITE_WORD:
900 EM4xWriteWord(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
901 break;
902 case CMD_AWID_DEMOD_FSK: // Set realtime AWID demodulation
903 CmdAWIDdemodFSK(c->arg[0], 0, 0, 1);
904 break;
905 #endif
906
907 #ifdef WITH_HITAG
908 case CMD_SNOOP_HITAG: // Eavesdrop Hitag tag, args = type
909 SnoopHitag(c->arg[0]);
910 break;
911 case CMD_SIMULATE_HITAG: // Simulate Hitag tag, args = memory content
912 SimulateHitagTag((bool)c->arg[0],(byte_t*)c->d.asBytes);
913 break;
914 case CMD_READER_HITAG: // Reader for Hitag tags, args = type and function
915 ReaderHitag((hitag_function)c->arg[0],(hitag_data*)c->d.asBytes);
916 break;
917 #endif
918
919 #ifdef WITH_ISO15693
920 case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693:
921 AcquireRawAdcSamplesIso15693();
922 break;
923 case CMD_RECORD_RAW_ADC_SAMPLES_ISO_15693:
924 RecordRawAdcSamplesIso15693();
925 break;
926
927 case CMD_ISO_15693_COMMAND:
928 DirectTag15693Command(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
929 break;
930
931 case CMD_ISO_15693_FIND_AFI:
932 BruteforceIso15693Afi(c->arg[0]);
933 break;
934
935 case CMD_ISO_15693_DEBUG:
936 SetDebugIso15693(c->arg[0]);
937 break;
938
939 case CMD_READER_ISO_15693:
940 ReaderIso15693(c->arg[0]);
941 break;
942 case CMD_SIMTAG_ISO_15693:
943 SimTagIso15693(c->arg[0], c->d.asBytes);
944 break;
945 #endif
946
947 #ifdef WITH_LEGICRF
948 case CMD_SIMULATE_TAG_LEGIC_RF:
949 LegicRfSimulate(c->arg[0], c->arg[1], c->arg[2]);
950 break;
951
952 case CMD_WRITER_LEGIC_RF:
953 LegicRfWriter(c->arg[1], c->arg[0]);
954 break;
955
956 case CMD_READER_LEGIC_RF:
957 LegicRfReader(c->arg[0], c->arg[1]);
958 break;
959 #endif
960
961 #ifdef WITH_ISO14443b
962 case CMD_READ_SRI512_TAG:
963 ReadSTMemoryIso14443b(0x0F);
964 break;
965 case CMD_READ_SRIX4K_TAG:
966 ReadSTMemoryIso14443b(0x7F);
967 break;
968 case CMD_SNOOP_ISO_14443B:
969 SnoopIso14443b();
970 break;
971 case CMD_SIMULATE_TAG_ISO_14443B:
972 SimulateIso14443bTag();
973 break;
974 case CMD_ISO_14443B_COMMAND:
975 SendRawCommand14443B(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
976 break;
977 #endif
978
979 #ifdef WITH_ISO14443a
980 case CMD_SNOOP_ISO_14443a:
981 SnoopIso14443a(c->arg[0]);
982 break;
983 case CMD_READER_ISO_14443a:
984 ReaderIso14443a(c);
985 break;
986 case CMD_SIMULATE_TAG_ISO_14443a:
987 SimulateIso14443aTag(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes); // ## Simulate iso14443a tag - pass tag type & UID
988 break;
989
990 case CMD_EPA_PACE_COLLECT_NONCE:
991 EPA_PACE_Collect_Nonce(c);
992 break;
993 case CMD_EPA_PACE_REPLAY:
994 EPA_PACE_Replay(c);
995 break;
996
997 case CMD_READER_MIFARE:
998 ReaderMifare(c->arg[0]);
999 break;
1000 case CMD_MIFARE_READBL:
1001 MifareReadBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1002 break;
1003 case CMD_MIFAREU_READBL:
1004 MifareUReadBlock(c->arg[0],c->arg[1], c->d.asBytes);
1005 break;
1006 case CMD_MIFAREUC_AUTH:
1007 MifareUC_Auth(c->arg[0],c->d.asBytes);
1008 break;
1009 case CMD_MIFAREU_READCARD:
1010 MifareUReadCard(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1011 break;
1012 case CMD_MIFAREUC_SETPWD:
1013 MifareUSetPwd(c->arg[0], c->d.asBytes);
1014 break;
1015 case CMD_MIFARE_READSC:
1016 MifareReadSector(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1017 break;
1018 case CMD_MIFARE_WRITEBL:
1019 MifareWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1020 break;
1021 //case CMD_MIFAREU_WRITEBL_COMPAT:
1022 //MifareUWriteBlockCompat(c->arg[0], c->d.asBytes);
1023 //break;
1024 case CMD_MIFAREU_WRITEBL:
1025 MifareUWriteBlock(c->arg[0], c->arg[1], c->d.asBytes);
1026 break;
1027 case CMD_MIFARE_NESTED:
1028 MifareNested(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1029 break;
1030 case CMD_MIFARE_CHKKEYS:
1031 MifareChkKeys(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1032 break;
1033 case CMD_SIMULATE_MIFARE_CARD:
1034 Mifare1ksim(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1035 break;
1036
1037 // emulator
1038 case CMD_MIFARE_SET_DBGMODE:
1039 MifareSetDbgLvl(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1040 break;
1041 case CMD_MIFARE_EML_MEMCLR:
1042 MifareEMemClr(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1043 break;
1044 case CMD_MIFARE_EML_MEMSET:
1045 MifareEMemSet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1046 break;
1047 case CMD_MIFARE_EML_MEMGET:
1048 MifareEMemGet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1049 break;
1050 case CMD_MIFARE_EML_CARDLOAD:
1051 MifareECardLoad(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1052 break;
1053
1054 // Work with "magic Chinese" card
1055 case CMD_MIFARE_CSETBLOCK:
1056 MifareCSetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1057 break;
1058 case CMD_MIFARE_CGETBLOCK:
1059 MifareCGetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1060 break;
1061 case CMD_MIFARE_CIDENT:
1062 MifareCIdent();
1063 break;
1064
1065 // mifare sniffer
1066 case CMD_MIFARE_SNIFFER:
1067 SniffMifare(c->arg[0]);
1068 break;
1069
1070 #endif
1071
1072 #ifdef WITH_ICLASS
1073 // Makes use of ISO14443a FPGA Firmware
1074 case CMD_SNOOP_ICLASS:
1075 SnoopIClass();
1076 break;
1077 case CMD_SIMULATE_TAG_ICLASS:
1078 SimulateIClass(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
1079 break;
1080 case CMD_READER_ICLASS:
1081 ReaderIClass(c->arg[0]);
1082 break;
1083 case CMD_READER_ICLASS_REPLAY:
1084 ReaderIClass_Replay(c->arg[0], c->d.asBytes);
1085 break;
1086 case CMD_ICLASS_EML_MEMSET:
1087 emlSet(c->d.asBytes,c->arg[0], c->arg[1]);
1088 break;
1089 #endif
1090
1091 case CMD_BUFF_CLEAR:
1092 BigBuf_Clear();
1093 break;
1094
1095 case CMD_MEASURE_ANTENNA_TUNING:
1096 MeasureAntennaTuning();
1097 break;
1098
1099 case CMD_MEASURE_ANTENNA_TUNING_HF:
1100 MeasureAntennaTuningHf();
1101 break;
1102
1103 case CMD_LISTEN_READER_FIELD:
1104 ListenReaderField(c->arg[0]);
1105 break;
1106
1107 case CMD_FPGA_MAJOR_MODE_OFF: // ## FPGA Control
1108 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
1109 SpinDelay(200);
1110 LED_D_OFF(); // LED D indicates field ON or OFF
1111 break;
1112
1113 case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K:
1114
1115 LED_B_ON();
1116 uint8_t *BigBuf = BigBuf_get_addr();
1117 for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
1118 size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
1119 cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,BigBuf_get_traceLen(),BigBuf+c->arg[0]+i,len);
1120 }
1121 // Trigger a finish downloading signal with an ACK frame
1122 cmd_send(CMD_ACK,1,0,BigBuf_get_traceLen(),getSamplingConfig(),sizeof(sample_config));
1123 LED_B_OFF();
1124 break;
1125
1126 case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
1127 uint8_t *b = BigBuf_get_addr();
1128 memcpy(b+c->arg[0], c->d.asBytes, USB_CMD_DATA_SIZE);
1129 cmd_send(CMD_ACK,0,0,0,0,0);
1130 break;
1131 }
1132 case CMD_READ_MEM:
1133 ReadMem(c->arg[0]);
1134 break;
1135
1136 case CMD_SET_LF_DIVISOR:
1137 FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
1138 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, c->arg[0]);
1139 break;
1140
1141 case CMD_SET_ADC_MUX:
1142 switch(c->arg[0]) {
1143 case 0: SetAdcMuxFor(GPIO_MUXSEL_LOPKD); break;
1144 case 1: SetAdcMuxFor(GPIO_MUXSEL_LORAW); break;
1145 case 2: SetAdcMuxFor(GPIO_MUXSEL_HIPKD); break;
1146 case 3: SetAdcMuxFor(GPIO_MUXSEL_HIRAW); break;
1147 }
1148 break;
1149
1150 case CMD_VERSION:
1151 SendVersion();
1152 break;
1153
1154 #ifdef WITH_LCD
1155 case CMD_LCD_RESET:
1156 LCDReset();
1157 break;
1158 case CMD_LCD:
1159 LCDSend(c->arg[0]);
1160 break;
1161 #endif
1162 case CMD_SETUP_WRITE:
1163 case CMD_FINISH_WRITE:
1164 case CMD_HARDWARE_RESET:
1165 usb_disable();
1166 SpinDelay(1000);
1167 SpinDelay(1000);
1168 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
1169 for(;;) {
1170 // We're going to reset, and the bootrom will take control.
1171 }
1172 break;
1173
1174 case CMD_START_FLASH:
1175 if(common_area.flags.bootrom_present) {
1176 common_area.command = COMMON_AREA_COMMAND_ENTER_FLASH_MODE;
1177 }
1178 usb_disable();
1179 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
1180 for(;;);
1181 break;
1182
1183 case CMD_DEVICE_INFO: {
1184 uint32_t dev_info = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS;
1185 if(common_area.flags.bootrom_present) dev_info |= DEVICE_INFO_FLAG_BOOTROM_PRESENT;
1186 cmd_send(CMD_DEVICE_INFO,dev_info,0,0,0,0);
1187 break;
1188 }
1189 default:
1190 Dbprintf("%s: 0x%04x","unknown command:",c->cmd);
1191 break;
1192 }
1193 }
1194
1195 void __attribute__((noreturn)) AppMain(void)
1196 {
1197 SpinDelay(100);
1198 clear_trace();
1199 if(common_area.magic != COMMON_AREA_MAGIC || common_area.version != 1) {
1200 /* Initialize common area */
1201 memset(&common_area, 0, sizeof(common_area));
1202 common_area.magic = COMMON_AREA_MAGIC;
1203 common_area.version = 1;
1204 }
1205 common_area.flags.osimage_present = 1;
1206
1207 LED_D_OFF();
1208 LED_C_OFF();
1209 LED_B_OFF();
1210 LED_A_OFF();
1211
1212 // Init USB device
1213 usb_enable();
1214
1215 // The FPGA gets its clock from us from PCK0 output, so set that up.
1216 AT91C_BASE_PIOA->PIO_BSR = GPIO_PCK0;
1217 AT91C_BASE_PIOA->PIO_PDR = GPIO_PCK0;
1218 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_PCK0;
1219 // PCK0 is PLL clock / 4 = 96Mhz / 4 = 24Mhz
1220 AT91C_BASE_PMC->PMC_PCKR[0] = AT91C_PMC_CSS_PLL_CLK |
1221 AT91C_PMC_PRES_CLK_4;
1222 AT91C_BASE_PIOA->PIO_OER = GPIO_PCK0;
1223
1224 // Reset SPI
1225 AT91C_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
1226 // Reset SSC
1227 AT91C_BASE_SSC->SSC_CR = AT91C_SSC_SWRST;
1228
1229 // Load the FPGA image, which we have stored in our flash.
1230 // (the HF version by default)
1231 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
1232
1233 StartTickCount();
1234
1235 #ifdef WITH_LCD
1236 LCDInit();
1237 #endif
1238
1239 byte_t rx[sizeof(UsbCommand)];
1240 size_t rx_len;
1241
1242 for(;;) {
1243 if (usb_poll()) {
1244 rx_len = usb_read(rx,sizeof(UsbCommand));
1245 if (rx_len) {
1246 UsbPacketReceived(rx,rx_len);
1247 }
1248 }
1249 WDT_HIT();
1250
1251 #ifdef WITH_LF
1252 #ifndef WITH_ISO14443a_StandAlone
1253 if (BUTTON_HELD(1000) > 0)
1254 SamyRun();
1255 #endif
1256 #endif
1257 #ifdef WITH_ISO14443a
1258 #ifdef WITH_ISO14443a_StandAlone
1259 if (BUTTON_HELD(1000) > 0)
1260 StandAloneMode14a();
1261 #endif
1262 #endif
1263 }
1264 }
Proxmark3 GIT tracking
Impressum, Datenschutz