git.zerfleddert.de Git - proxmark3-svn/blob - armsrc/appmain.c

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