]> git.zerfleddert.de Git - proxmark3-svn/blob - armsrc/appmain.c
projects / proxmark3-svn / blob
? search:


bdd04757f7a7da13d6606ca4e4f179d836a2cd22
[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
27 #ifdef WITH_LCD
28 #include "LCD.h"
29 #endif
30
31 #define abs(x) ( ((x)<0) ? -(x) : (x) )
32
33 //=============================================================================
34 // A buffer where we can queue things up to be sent through the FPGA, for
35 // any purpose (fake tag, as reader, whatever). We go MSB first, since that
36 // is the order in which they go out on the wire.
37 //=============================================================================
38
39 uint8_t ToSend[512];
40 int ToSendMax;
41 static int ToSendBit;
42 struct common_area common_area __attribute__((section(".commonarea")));
43
44 void BufferClear(void)
45 {
46 memset(BigBuf,0,sizeof(BigBuf));
47 Dbprintf("Buffer cleared (%i bytes)",sizeof(BigBuf));
48 }
49
50 void ToSendReset(void)
51 {
52 ToSendMax = -1;
53 ToSendBit = 8;
54 }
55
56 void ToSendStuffBit(int b)
57 {
58 if(ToSendBit >= 8) {
59 ToSendMax++;
60 ToSend[ToSendMax] = 0;
61 ToSendBit = 0;
62 }
63
64 if(b) {
65 ToSend[ToSendMax] |= (1 << (7 - ToSendBit));
66 }
67
68 ToSendBit++;
69
70 if(ToSendBit >= sizeof(ToSend)) {
71 ToSendBit = 0;
72 DbpString("ToSendStuffBit overflowed!");
73 }
74 }
75
76 //=============================================================================
77 // Debug print functions, to go out over USB, to the usual PC-side client.
78 //=============================================================================
79
80 void DbpString(char *str)
81 {
82 byte_t len = strlen(str);
83 cmd_send(CMD_DEBUG_PRINT_STRING,len,0,0,(byte_t*)str,len);
84 // /* this holds up stuff unless we're connected to usb */
85 // if (!UsbConnected())
86 // return;
87 //
88 // UsbCommand c;
89 // c.cmd = CMD_DEBUG_PRINT_STRING;
90 // c.arg[0] = strlen(str);
91 // if(c.arg[0] > sizeof(c.d.asBytes)) {
92 // c.arg[0] = sizeof(c.d.asBytes);
93 // }
94 // memcpy(c.d.asBytes, str, c.arg[0]);
95 //
96 // UsbSendPacket((uint8_t *)&c, sizeof(c));
97 // // TODO fix USB so stupid things like this aren't req'd
98 // SpinDelay(50);
99 }
100
101 #if 0
102 void DbpIntegers(int x1, int x2, int x3)
103 {
104 cmd_send(CMD_DEBUG_PRINT_INTEGERS,x1,x2,x3,0,0);
105 // /* this holds up stuff unless we're connected to usb */
106 // if (!UsbConnected())
107 // return;
108 //
109 // UsbCommand c;
110 // c.cmd = CMD_DEBUG_PRINT_INTEGERS;
111 // c.arg[0] = x1;
112 // c.arg[1] = x2;
113 // c.arg[2] = x3;
114 //
115 // UsbSendPacket((uint8_t *)&c, sizeof(c));
116 // // XXX
117 // SpinDelay(50);
118 }
119 #endif
120
121 void Dbprintf(const char *fmt, ...) {
122 // should probably limit size here; oh well, let's just use a big buffer
123 char output_string[128];
124 va_list ap;
125
126 va_start(ap, fmt);
127 kvsprintf(fmt, output_string, 10, ap);
128 va_end(ap);
129
130 DbpString(output_string);
131 }
132
133 // prints HEX & ASCII
134 void Dbhexdump(int len, uint8_t *d, bool bAsci) {
135 int l=0,i;
136 char ascii[9];
137
138 while (len>0) {
139 if (len>8) l=8;
140 else l=len;
141
142 memcpy(ascii,d,l);
143 ascii[l]=0;
144
145 // filter safe ascii
146 for (i=0;i<l;i++)
147 if (ascii[i]<32 || ascii[i]>126) ascii[i]='.';
148
149 if (bAsci) {
150 Dbprintf("%-8s %*D",ascii,l,d," ");
151 } else {
152 Dbprintf("%*D",l,d," ");
153 }
154
155 len-=8;
156 d+=8;
157 }
158 }
159
160 //-----------------------------------------------------------------------------
161 // Read an ADC channel and block till it completes, then return the result
162 // in ADC units (0 to 1023). Also a routine to average 32 samples and
163 // return that.
164 //-----------------------------------------------------------------------------
165 static int ReadAdc(int ch)
166 {
167 uint32_t d;
168
169 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
170 AT91C_BASE_ADC->ADC_MR =
171 ADC_MODE_PRESCALE(32) |
172 ADC_MODE_STARTUP_TIME(16) |
173 ADC_MODE_SAMPLE_HOLD_TIME(8);
174 AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ch);
175
176 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
177 while(!(AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ch)))
178 ;
179 d = AT91C_BASE_ADC->ADC_CDR[ch];
180
181 return d;
182 }
183
184 int AvgAdc(int ch) // was static - merlok
185 {
186 int i;
187 int a = 0;
188
189 for(i = 0; i < 32; i++) {
190 a += ReadAdc(ch);
191 }
192
193 return (a + 15) >> 5;
194 }
195
196 void MeasureAntennaTuning(void)
197 {
198 uint8_t *dest = (uint8_t *)BigBuf+FREE_BUFFER_OFFSET;
199 int i, adcval = 0, peak = 0, peakv = 0, peakf = 0; //ptr = 0
200 int vLf125 = 0, vLf134 = 0, vHf = 0; // in mV
201
202 // UsbCommand c;
203
204 LED_B_ON();
205 DbpString("Measuring antenna characteristics, please wait...");
206 memset(dest,0,sizeof(FREE_BUFFER_SIZE));
207
208 /*
209 * Sweeps the useful LF range of the proxmark from
210 * 46.8kHz (divisor=255) to 600kHz (divisor=19) and
211 * read the voltage in the antenna, the result left
212 * in the buffer is a graph which should clearly show
213 * the resonating frequency of your LF antenna
214 * ( hopefully around 95 if it is tuned to 125kHz!)
215 */
216
217 FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_READER);
218 for (i=255; i>19; i--) {
219 WDT_HIT();
220 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, i);
221 SpinDelay(20);
222 // Vref = 3.3V, and a 10000:240 voltage divider on the input
223 // can measure voltages up to 137500 mV
224 adcval = ((137500 * AvgAdc(ADC_CHAN_LF)) >> 10);
225 if (i==95) vLf125 = adcval; // voltage at 125Khz
226 if (i==89) vLf134 = adcval; // voltage at 134Khz
227
228 dest[i] = adcval>>8; // scale int to fit in byte for graphing purposes
229 if(dest[i] > peak) {
230 peakv = adcval;
231 peak = dest[i];
232 peakf = i;
233 //ptr = i;
234 }
235 }
236
237 LED_A_ON();
238 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
239 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
240 SpinDelay(20);
241 // Vref = 3300mV, and an 10:1 voltage divider on the input
242 // can measure voltages up to 33000 mV
243 vHf = (33000 * AvgAdc(ADC_CHAN_HF)) >> 10;
244
245 // c.cmd = CMD_MEASURED_ANTENNA_TUNING;
246 // c.arg[0] = (vLf125 << 0) | (vLf134 << 16);
247 // c.arg[1] = vHf;
248 // c.arg[2] = peakf | (peakv << 16);
249
250 DbpString("Measuring complete, sending report back to host");
251 cmd_send(CMD_MEASURED_ANTENNA_TUNING,vLf125|(vLf134<<16),vHf,peakf|(peakv<<16),0,0);
252 // UsbSendPacket((uint8_t *)&c, sizeof(c));
253 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
254 LED_A_OFF();
255 LED_B_OFF();
256 return;
257 }
258
259 void MeasureAntennaTuningHf(void)
260 {
261 int vHf = 0; // in mV
262
263 DbpString("Measuring HF antenna, press button to exit");
264
265 for (;;) {
266 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
267 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
268 SpinDelay(20);
269 // Vref = 3300mV, and an 10:1 voltage divider on the input
270 // can measure voltages up to 33000 mV
271 vHf = (33000 * AvgAdc(ADC_CHAN_HF)) >> 10;
272
273 Dbprintf("%d mV",vHf);
274 if (BUTTON_PRESS()) break;
275 }
276 DbpString("cancelled");
277 }
278
279
280 void SimulateTagHfListen(void)
281 {
282 uint8_t *dest = (uint8_t *)BigBuf+FREE_BUFFER_OFFSET;
283 uint8_t v = 0;
284 int i;
285 int p = 0;
286
287 // We're using this mode just so that I can test it out; the simulated
288 // tag mode would work just as well and be simpler.
289 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR | FPGA_HF_READER_RX_XCORR_848_KHZ | FPGA_HF_READER_RX_XCORR_SNOOP);
290
291 // We need to listen to the high-frequency, peak-detected path.
292 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
293
294 FpgaSetupSsc();
295
296 i = 0;
297 for(;;) {
298 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
299 AT91C_BASE_SSC->SSC_THR = 0xff;
300 }
301 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
302 uint8_t r = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
303
304 v <<= 1;
305 if(r & 1) {
306 v |= 1;
307 }
308 p++;
309
310 if(p >= 8) {
311 dest[i] = v;
312 v = 0;
313 p = 0;
314 i++;
315
316 if(i >= FREE_BUFFER_SIZE) {
317 break;
318 }
319 }
320 }
321 }
322 DbpString("simulate tag (now type bitsamples)");
323 }
324
325 void ReadMem(int addr)
326 {
327 const uint8_t *data = ((uint8_t *)addr);
328
329 Dbprintf("%x: %02x %02x %02x %02x %02x %02x %02x %02x",
330 addr, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
331 }
332
333 /* osimage version information is linked in */
334 extern struct version_information version_information;
335 /* bootrom version information is pointed to from _bootphase1_version_pointer */
336 extern char *_bootphase1_version_pointer, _flash_start, _flash_end;
337 void SendVersion(void)
338 {
339 char temp[48]; /* Limited data payload in USB packets */
340 DbpString("Prox/RFID mark3 RFID instrument");
341
342 /* Try to find the bootrom version information. Expect to find a pointer at
343 * symbol _bootphase1_version_pointer, perform slight sanity checks on the
344 * pointer, then use it.
345 */
346 char *bootrom_version = *(char**)&_bootphase1_version_pointer;
347 if( bootrom_version < &_flash_start || bootrom_version >= &_flash_end ) {
348 DbpString("bootrom version information appears invalid");
349 } else {
350 FormatVersionInformation(temp, sizeof(temp), "bootrom: ", bootrom_version);
351 DbpString(temp);
352 }
353
354 FormatVersionInformation(temp, sizeof(temp), "os: ", &version_information);
355 DbpString(temp);
356
357 FpgaGatherVersion(temp, sizeof(temp));
358 DbpString(temp);
359 }
360
361 #ifdef WITH_LF
362 // samy's sniff and repeat routine
363 void SamyRun()
364 {
365 DbpString("Stand-alone mode! No PC necessary.");
366
367 // 3 possible options? no just 2 for now
368 #define OPTS 2
369
370 int high[OPTS], low[OPTS];
371
372 // Oooh pretty -- notify user we're in elite samy mode now
373 LED(LED_RED, 200);
374 LED(LED_ORANGE, 200);
375 LED(LED_GREEN, 200);
376 LED(LED_ORANGE, 200);
377 LED(LED_RED, 200);
378 LED(LED_ORANGE, 200);
379 LED(LED_GREEN, 200);
380 LED(LED_ORANGE, 200);
381 LED(LED_RED, 200);
382
383 int selected = 0;
384 int playing = 0;
385
386 // Turn on selected LED
387 LED(selected + 1, 0);
388
389 for (;;)
390 {
391 // UsbPoll(FALSE);
392 usb_poll();
393 WDT_HIT();
394
395 // Was our button held down or pressed?
396 int button_pressed = BUTTON_HELD(1000);
397 SpinDelay(300);
398
399 // Button was held for a second, begin recording
400 if (button_pressed > 0)
401 {
402 LEDsoff();
403 LED(selected + 1, 0);
404 LED(LED_RED2, 0);
405
406 // record
407 DbpString("Starting recording");
408
409 // wait for button to be released
410 while(BUTTON_PRESS())
411 WDT_HIT();
412
413 /* need this delay to prevent catching some weird data */
414 SpinDelay(500);
415
416 CmdHIDdemodFSK(1, &high[selected], &low[selected], 0);
417 Dbprintf("Recorded %x %x %x", selected, high[selected], low[selected]);
418
419 LEDsoff();
420 LED(selected + 1, 0);
421 // Finished recording
422
423 // If we were previously playing, set playing off
424 // so next button push begins playing what we recorded
425 playing = 0;
426 }
427
428 // Change where to record (or begin playing)
429 else if (button_pressed)
430 {
431 // Next option if we were previously playing
432 if (playing)
433 selected = (selected + 1) % OPTS;
434 playing = !playing;
435
436 LEDsoff();
437 LED(selected + 1, 0);
438
439 // Begin transmitting
440 if (playing)
441 {
442 LED(LED_GREEN, 0);
443 DbpString("Playing");
444 // wait for button to be released
445 while(BUTTON_PRESS())
446 WDT_HIT();
447 Dbprintf("%x %x %x", selected, high[selected], low[selected]);
448 CmdHIDsimTAG(high[selected], low[selected], 0);
449 DbpString("Done playing");
450 if (BUTTON_HELD(1000) > 0)
451 {
452 DbpString("Exiting");
453 LEDsoff();
454 return;
455 }
456
457 /* We pressed a button so ignore it here with a delay */
458 SpinDelay(300);
459
460 // when done, we're done playing, move to next option
461 selected = (selected + 1) % OPTS;
462 playing = !playing;
463 LEDsoff();
464 LED(selected + 1, 0);
465 }
466 else
467 while(BUTTON_PRESS())
468 WDT_HIT();
469 }
470 }
471 }
472 #endif
473
474 /*
475 OBJECTIVE
476 Listen and detect an external reader. Determine the best location
477 for the antenna.
478
479 INSTRUCTIONS:
480 Inside the ListenReaderField() function, there is two mode.
481 By default, when you call the function, you will enter mode 1.
482 If you press the PM3 button one time, you will enter mode 2.
483 If you press the PM3 button a second time, you will exit the function.
484
485 DESCRIPTION OF MODE 1:
486 This mode just listens for an external reader field and lights up green
487 for HF and/or red for LF. This is the original mode of the detectreader
488 function.
489
490 DESCRIPTION OF MODE 2:
491 This mode will visually represent, using the LEDs, the actual strength of the
492 current compared to the maximum current detected. Basically, once you know
493 what kind of external reader is present, it will help you spot the best location to place
494 your antenna. You will probably not get some good results if there is a LF and a HF reader
495 at the same place! :-)
496
497 LIGHT SCHEME USED:
498 */
499 static const char LIGHT_SCHEME[] = {
500 0x0, /* ---- | No field detected */
501 0x1, /* X--- | 14% of maximum current detected */
502 0x2, /* -X-- | 29% of maximum current detected */
503 0x4, /* --X- | 43% of maximum current detected */
504 0x8, /* ---X | 57% of maximum current detected */
505 0xC, /* --XX | 71% of maximum current detected */
506 0xE, /* -XXX | 86% of maximum current detected */
507 0xF, /* XXXX | 100% of maximum current detected */
508 };
509 static const int LIGHT_LEN = sizeof(LIGHT_SCHEME)/sizeof(LIGHT_SCHEME[0]);
510
511 void ListenReaderField(int limit)
512 {
513 int lf_av, lf_av_new, lf_baseline= 0, lf_count= 0, lf_max;
514 int hf_av, hf_av_new, hf_baseline= 0, hf_count= 0, hf_max;
515 int mode=1, display_val, display_max, i;
516
517 #define LF_ONLY 1
518 #define HF_ONLY 2
519
520 LEDsoff();
521
522 lf_av=lf_max=ReadAdc(ADC_CHAN_LF);
523
524 if(limit != HF_ONLY) {
525 Dbprintf("LF 125/134 Baseline: %d", lf_av);
526 lf_baseline = lf_av;
527 }
528
529 hf_av=hf_max=ReadAdc(ADC_CHAN_HF);
530
531 if (limit != LF_ONLY) {
532 Dbprintf("HF 13.56 Baseline: %d", hf_av);
533 hf_baseline = hf_av;
534 }
535
536 for(;;) {
537 if (BUTTON_PRESS()) {
538 SpinDelay(500);
539 switch (mode) {
540 case 1:
541 mode=2;
542 DbpString("Signal Strength Mode");
543 break;
544 case 2:
545 default:
546 DbpString("Stopped");
547 LEDsoff();
548 return;
549 break;
550 }
551 }
552 WDT_HIT();
553
554 if (limit != HF_ONLY) {
555 if(mode==1) {
556 if (abs(lf_av - lf_baseline) > 10) LED_D_ON();
557 else LED_D_OFF();
558 }
559
560 ++lf_count;
561 lf_av_new= ReadAdc(ADC_CHAN_LF);
562 // see if there's a significant change
563 if(abs(lf_av - lf_av_new) > 10) {
564 Dbprintf("LF 125/134 Field Change: %x %x %x", lf_av, lf_av_new, lf_count);
565 lf_av = lf_av_new;
566 if (lf_av > lf_max)
567 lf_max = lf_av;
568 lf_count= 0;
569 }
570 }
571
572 if (limit != LF_ONLY) {
573 if (mode == 1){
574 if (abs(hf_av - hf_baseline) > 10) LED_B_ON();
575 else LED_B_OFF();
576 }
577
578 ++hf_count;
579 hf_av_new= ReadAdc(ADC_CHAN_HF);
580 // see if there's a significant change
581 if(abs(hf_av - hf_av_new) > 10) {
582 Dbprintf("HF 13.56 Field Change: %x %x %x", hf_av, hf_av_new, hf_count);
583 hf_av = hf_av_new;
584 if (hf_av > hf_max)
585 hf_max = hf_av;
586 hf_count= 0;
587 }
588 }
589
590 if(mode == 2) {
591 if (limit == LF_ONLY) {
592 display_val = lf_av;
593 display_max = lf_max;
594 } else if (limit == HF_ONLY) {
595 display_val = hf_av;
596 display_max = hf_max;
597 } else { /* Pick one at random */
598 if( (hf_max - hf_baseline) > (lf_max - lf_baseline) ) {
599 display_val = hf_av;
600 display_max = hf_max;
601 } else {
602 display_val = lf_av;
603 display_max = lf_max;
604 }
605 }
606 for (i=0; i<LIGHT_LEN; i++) {
607 if (display_val >= ((display_max/LIGHT_LEN)*i) && display_val <= ((display_max/LIGHT_LEN)*(i+1))) {
608 if (LIGHT_SCHEME[i] & 0x1) LED_C_ON(); else LED_C_OFF();
609 if (LIGHT_SCHEME[i] & 0x2) LED_A_ON(); else LED_A_OFF();
610 if (LIGHT_SCHEME[i] & 0x4) LED_B_ON(); else LED_B_OFF();
611 if (LIGHT_SCHEME[i] & 0x8) LED_D_ON(); else LED_D_OFF();
612 break;
613 }
614 }
615 }
616 }
617 }
618
619 void UsbPacketReceived(uint8_t *packet, int len)
620 {
621 UsbCommand *c = (UsbCommand *)packet;
622
623 // 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]);
624
625 switch(c->cmd) {
626 #ifdef WITH_LF
627 case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
628 AcquireRawAdcSamples125k(c->arg[0]);
629 cmd_send(CMD_ACK,0,0,0,0,0);
630 break;
631 case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
632 ModThenAcquireRawAdcSamples125k(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
633 break;
634 case CMD_HID_DEMOD_FSK:
635 CmdHIDdemodFSK(0, 0, 0, 1); // Demodulate HID tag
636 break;
637 case CMD_HID_SIM_TAG:
638 CmdHIDsimTAG(c->arg[0], c->arg[1], 1); // Simulate HID tag by ID
639 break;
640 case CMD_HID_CLONE_TAG:
641 CopyHIDtoT55x7(c->arg[0], c->arg[1]); // Clone HID tag by ID to T55x7
642 break;
643 case CMD_EM410X_WRITE_TAG:
644 WriteEM410x(c->arg[0], c->arg[1], c->arg[2]);
645 break;
646 case CMD_READ_TI_TYPE:
647 ReadTItag();
648 break;
649 case CMD_WRITE_TI_TYPE:
650 WriteTItag(c->arg[0],c->arg[1],c->arg[2]);
651 break;
652 case CMD_SIMULATE_TAG_125K:
653 LED_A_ON();
654 SimulateTagLowFrequency(c->arg[0], c->arg[1], 1);
655 LED_A_OFF();
656 break;
657 case CMD_LF_SIMULATE_BIDIR:
658 SimulateTagLowFrequencyBidir(c->arg[0], c->arg[1]);
659 break;
660 case CMD_INDALA_CLONE_TAG: // Clone Indala 64-bit tag by UID to T55x7
661 CopyIndala64toT55x7(c->arg[0], c->arg[1]);
662 break;
663 case CMD_INDALA_CLONE_TAG_L: // Clone Indala 224-bit tag by UID to T55x7
664 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]);
665 break;
666 #endif
667
668 #ifdef WITH_HITAG
669 case CMD_SNOOP_HITAG: // Eavesdrop Hitag tag, args = type
670 SnoopHitag(c->arg[0]);
671 break;
672 case CMD_SIMULATE_HITAG: // Simulate Hitag tag, args = memory content
673 SimulateHitagTag((bool)c->arg[0],(byte_t*)c->d.asBytes);
674 break;
675 case CMD_READER_HITAG: // Reader for Hitag tags, args = type and function
676 ReaderHitag((hitag_function)c->arg[0],(hitag_data*)c->d.asBytes);
677 break;
678 #endif
679
680 #ifdef WITH_ISO15693
681 case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693:
682 AcquireRawAdcSamplesIso15693();
683 break;
684 case CMD_RECORD_RAW_ADC_SAMPLES_ISO_15693:
685 RecordRawAdcSamplesIso15693();
686 break;
687
688 case CMD_ISO_15693_COMMAND:
689 DirectTag15693Command(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
690 break;
691
692 case CMD_ISO_15693_FIND_AFI:
693 BruteforceIso15693Afi(c->arg[0]);
694 break;
695
696 case CMD_ISO_15693_DEBUG:
697 SetDebugIso15693(c->arg[0]);
698 break;
699
700 case CMD_READER_ISO_15693:
701 ReaderIso15693(c->arg[0]);
702 break;
703 case CMD_SIMTAG_ISO_15693:
704 SimTagIso15693(c->arg[0]);
705 break;
706 #endif
707
708 #ifdef WITH_LEGICRF
709 case CMD_SIMULATE_TAG_LEGIC_RF:
710 LegicRfSimulate(c->arg[0], c->arg[1], c->arg[2]);
711 break;
712
713 case CMD_WRITER_LEGIC_RF:
714 LegicRfWriter(c->arg[1], c->arg[0]);
715 break;
716
717 case CMD_READER_LEGIC_RF:
718 LegicRfReader(c->arg[0], c->arg[1]);
719 break;
720 #endif
721
722 #ifdef WITH_ISO14443b
723 case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443:
724 AcquireRawAdcSamplesIso14443(c->arg[0]);
725 break;
726 case CMD_READ_SRI512_TAG:
727 ReadSRI512Iso14443(c->arg[0]);
728 break;
729 case CMD_READ_SRIX4K_TAG:
730 ReadSRIX4KIso14443(c->arg[0]);
731 break;
732 case CMD_SNOOP_ISO_14443:
733 SnoopIso14443();
734 break;
735 case CMD_SIMULATE_TAG_ISO_14443:
736 SimulateIso14443Tag();
737 break;
738 #endif
739
740 #ifdef WITH_ISO14443a
741 case CMD_SNOOP_ISO_14443a:
742 SnoopIso14443a(c->arg[0]);
743 break;
744 case CMD_READER_ISO_14443a:
745 ReaderIso14443a(c);
746 break;
747 case CMD_SIMULATE_TAG_ISO_14443a:
748 SimulateIso14443aTag(c->arg[0], c->arg[1], c->arg[2]); // ## Simulate iso14443a tag - pass tag type & UID
749 break;
750 case CMD_EPA_PACE_COLLECT_NONCE:
751 EPA_PACE_Collect_Nonce(c);
752 break;
753
754 case CMD_READER_MIFARE:
755 ReaderMifare(c->arg[0]);
756 break;
757 case CMD_MIFARE_READBL:
758 MifareReadBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
759 break;
760 case CMD_MIFARE_READSC:
761 MifareReadSector(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
762 break;
763 case CMD_MIFARE_WRITEBL:
764 MifareWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
765 break;
766 case CMD_MIFARE_NESTED:
767 MifareNested(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
768 break;
769 case CMD_MIFARE_CHKKEYS:
770 MifareChkKeys(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
771 break;
772 case CMD_SIMULATE_MIFARE_CARD:
773 Mifare1ksim(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
774 break;
775
776 // emulator
777 case CMD_MIFARE_SET_DBGMODE:
778 MifareSetDbgLvl(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
779 break;
780 case CMD_MIFARE_EML_MEMCLR:
781 MifareEMemClr(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
782 break;
783 case CMD_MIFARE_EML_MEMSET:
784 MifareEMemSet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
785 break;
786 case CMD_MIFARE_EML_MEMGET:
787 MifareEMemGet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
788 break;
789 case CMD_MIFARE_EML_CARDLOAD:
790 MifareECardLoad(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
791 break;
792
793 // Work with "magic Chinese" card
794 case CMD_MIFARE_EML_CSETBLOCK:
795 MifareCSetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
796 break;
797 case CMD_MIFARE_EML_CGETBLOCK:
798 MifareCGetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
799 break;
800
801 // mifare sniffer
802 case CMD_MIFARE_SNIFFER:
803 SniffMifare(c->arg[0]);
804 break;
805 #endif
806
807 #ifdef WITH_ICLASS
808 // Makes use of ISO14443a FPGA Firmware
809 case CMD_SNOOP_ICLASS:
810 SnoopIClass();
811 break;
812 case CMD_SIMULATE_TAG_ICLASS:
813 SimulateIClass(c->arg[0], c->d.asBytes);
814 break;
815 case CMD_READER_ICLASS:
816 ReaderIClass(c->arg[0]);
817 break;
818 #endif
819
820 case CMD_SIMULATE_TAG_HF_LISTEN:
821 SimulateTagHfListen();
822 break;
823
824 case CMD_BUFF_CLEAR:
825 BufferClear();
826 break;
827
828 case CMD_MEASURE_ANTENNA_TUNING:
829 MeasureAntennaTuning();
830 break;
831
832 case CMD_MEASURE_ANTENNA_TUNING_HF:
833 MeasureAntennaTuningHf();
834 break;
835
836 case CMD_LISTEN_READER_FIELD:
837 ListenReaderField(c->arg[0]);
838 break;
839
840 case CMD_FPGA_MAJOR_MODE_OFF: // ## FPGA Control
841 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
842 SpinDelay(200);
843 LED_D_OFF(); // LED D indicates field ON or OFF
844 break;
845
846 case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K: {
847 // UsbCommand n;
848 // if(c->cmd == CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K) {
849 // n.cmd = CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K;
850 // } else {
851 // n.cmd = CMD_DOWNLOADED_RAW_BITS_TI_TYPE;
852 // }
853 // n.arg[0] = c->arg[0];
854 // memcpy(n.d.asBytes, BigBuf+c->arg[0], 48); // 12*sizeof(uint32_t)
855 // LED_B_ON();
856 // usb_write((uint8_t *)&n, sizeof(n));
857 // UsbSendPacket((uint8_t *)&n, sizeof(n));
858 // LED_B_OFF();
859
860 LED_B_ON();
861 for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
862 size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
863 cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,0,((byte_t*)BigBuf)+c->arg[0]+i,len);
864 }
865 // Trigger a finish downloading signal with an ACK frame
866 cmd_send(CMD_ACK,0,0,0,0,0);
867 LED_B_OFF();
868 } break;
869
870 case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
871 uint8_t *b = (uint8_t *)BigBuf;
872 memcpy(b+c->arg[0], c->d.asBytes, 48);
873 //Dbprintf("copied 48 bytes to %i",b+c->arg[0]);
874 // UsbSendPacket((uint8_t*)&ack, sizeof(ack));
875 cmd_send(CMD_ACK,0,0,0,0,0);
876 } break;
877
878 case CMD_READ_MEM:
879 ReadMem(c->arg[0]);
880 break;
881
882 case CMD_SET_LF_DIVISOR:
883 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, c->arg[0]);
884 break;
885
886 case CMD_SET_ADC_MUX:
887 switch(c->arg[0]) {
888 case 0: SetAdcMuxFor(GPIO_MUXSEL_LOPKD); break;
889 case 1: SetAdcMuxFor(GPIO_MUXSEL_LORAW); break;
890 case 2: SetAdcMuxFor(GPIO_MUXSEL_HIPKD); break;
891 case 3: SetAdcMuxFor(GPIO_MUXSEL_HIRAW); break;
892 }
893 break;
894
895 case CMD_VERSION:
896 SendVersion();
897 break;
898
899 #ifdef WITH_LCD
900 case CMD_LCD_RESET:
901 LCDReset();
902 break;
903 case CMD_LCD:
904 LCDSend(c->arg[0]);
905 break;
906 #endif
907 case CMD_SETUP_WRITE:
908 case CMD_FINISH_WRITE:
909 case CMD_HARDWARE_RESET: {
910 usb_disable();
911 SpinDelay(1000);
912 SpinDelay(1000);
913 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
914 for(;;) {
915 // We're going to reset, and the bootrom will take control.
916 }
917 } break;
918
919 case CMD_START_FLASH: {
920 if(common_area.flags.bootrom_present) {
921 common_area.command = COMMON_AREA_COMMAND_ENTER_FLASH_MODE;
922 }
923 usb_disable();
924 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
925 for(;;);
926 } break;
927
928 case CMD_DEVICE_INFO: {
929 uint32_t dev_info = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS;
930 if(common_area.flags.bootrom_present) dev_info |= DEVICE_INFO_FLAG_BOOTROM_PRESENT;
931 // UsbSendPacket((uint8_t*)&c, sizeof(c));
932 cmd_send(CMD_DEVICE_INFO,dev_info,0,0,0,0);
933 } break;
934
935 default: {
936 Dbprintf("%s: 0x%04x","unknown command:",c->cmd);
937 } break;
938 }
939 }
940
941 void __attribute__((noreturn)) AppMain(void)
942 {
943 SpinDelay(100);
944
945 if(common_area.magic != COMMON_AREA_MAGIC || common_area.version != 1) {
946 /* Initialize common area */
947 memset(&common_area, 0, sizeof(common_area));
948 common_area.magic = COMMON_AREA_MAGIC;
949 common_area.version = 1;
950 }
951 common_area.flags.osimage_present = 1;
952
953 LED_D_OFF();
954 LED_C_OFF();
955 LED_B_OFF();
956 LED_A_OFF();
957
958 // Init USB device
959 usb_enable();
960 // UsbStart();
961
962 // The FPGA gets its clock from us from PCK0 output, so set that up.
963 AT91C_BASE_PIOA->PIO_BSR = GPIO_PCK0;
964 AT91C_BASE_PIOA->PIO_PDR = GPIO_PCK0;
965 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_PCK0;
966 // PCK0 is PLL clock / 4 = 96Mhz / 4 = 24Mhz
967 AT91C_BASE_PMC->PMC_PCKR[0] = AT91C_PMC_CSS_PLL_CLK |
968 AT91C_PMC_PRES_CLK_4;
969 AT91C_BASE_PIOA->PIO_OER = GPIO_PCK0;
970
971 // Reset SPI
972 AT91C_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
973 // Reset SSC
974 AT91C_BASE_SSC->SSC_CR = AT91C_SSC_SWRST;
975
976 // Load the FPGA image, which we have stored in our flash.
977 FpgaDownloadAndGo();
978
979 StartTickCount();
980
981 #ifdef WITH_LCD
982 LCDInit();
983 #endif
984
985 byte_t rx[sizeof(UsbCommand)];
986 size_t rx_len;
987
988 for(;;) {
989 if (usb_poll()) {
990 rx_len = usb_read(rx,sizeof(UsbCommand));
991 if (rx_len) {
992 UsbPacketReceived(rx,rx_len);
993 }
994 }
995 // UsbPoll(FALSE);
996
997 WDT_HIT();
998
999 #ifdef WITH_LF
1000 if (BUTTON_HELD(1000) > 0)
1001 SamyRun();
1002 #endif
1003 }
1004 }
Proxmark3 GIT tracking
Impressum, Datenschutz