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