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