[proxmark3-svn] / armsrc / appmain.c

//-----------------------------------------------------------------------------
// The main application code. This is the first thing called after start.c
// executes.
// Jonathan Westhues, Mar 2006
// Edits by Gerhard de Koning Gans, Sep 2007 (##)
//-----------------------------------------------------------------------------

#include <proxmark3.h>
#include <stdlib.h>
#include "apps.h"
#ifdef WITH_LCD
#include "fonts.h"
#include "LCD.h"
#endif


//=============================================================================
// A buffer where we can queue things up to be sent through the FPGA, for
// any purpose (fake tag, as reader, whatever). We go MSB first, since that
// is the order in which they go out on the wire.
//=============================================================================

BYTE ToSend[256];
int ToSendMax;
static int ToSendBit;

void BufferClear(void)
{
	memset(BigBuf,0,sizeof(BigBuf));
	DbpString("Buffer cleared");
}

void ToSendReset(void)
{
	ToSendMax = -1;
	ToSendBit = 8;
}

void ToSendStuffBit(int b)
{
	if(ToSendBit >= 8) {
		ToSendMax++;
		ToSend[ToSendMax] = 0;
		ToSendBit = 0;
	}

	if(b) {
		ToSend[ToSendMax] |= (1 << (7 - ToSendBit));
	}

	ToSendBit++;

	if(ToSendBit >= sizeof(ToSend)) {
		ToSendBit = 0;
		DbpString("ToSendStuffBit overflowed!");
	}
}

//=============================================================================
// Debug print functions, to go out over USB, to the usual PC-side client.
//=============================================================================

void DbpString(char *str)
{
	/* this holds up stuff unless we're connected to usb */
	if (!UsbConnected())
		return;

	UsbCommand c;
	c.cmd = CMD_DEBUG_PRINT_STRING;
	c.ext1 = strlen(str);
	memcpy(c.d.asBytes, str, c.ext1);

	UsbSendPacket((BYTE *)&c, sizeof(c));
	// TODO fix USB so stupid things like this aren't req'd
	SpinDelay(50);
}

void DbpIntegers(int x1, int x2, int x3)
{
	/* this holds up stuff unless we're connected to usb */
	if (!UsbConnected())
		return;

	UsbCommand c;
	c.cmd = CMD_DEBUG_PRINT_INTEGERS;
	c.ext1 = x1;
	c.ext2 = x2;
	c.ext3 = x3;

	UsbSendPacket((BYTE *)&c, sizeof(c));
	// XXX
	SpinDelay(50);
}

//-----------------------------------------------------------------------------
// Read an ADC channel and block till it completes, then return the result
// in ADC units (0 to 1023). Also a routine to average 32 samples and
// return that.
//-----------------------------------------------------------------------------
static int ReadAdc(int ch)
{
	DWORD d;

	ADC_CONTROL = ADC_CONTROL_RESET;
	ADC_MODE = ADC_MODE_PRESCALE(32) | ADC_MODE_STARTUP_TIME(16) |
		ADC_MODE_SAMPLE_HOLD_TIME(8);
	ADC_CHANNEL_ENABLE = ADC_CHANNEL(ch);

	ADC_CONTROL = ADC_CONTROL_START;
	while(!(ADC_STATUS & ADC_END_OF_CONVERSION(ch)))
		;
	d = ADC_CHANNEL_DATA(ch);

	return d;
}

static int AvgAdc(int ch)
{
	int i;
	int a = 0;

	for(i = 0; i < 32; i++) {
		a += ReadAdc(ch);
	}

	return (a + 15) >> 5;
}

void MeasureAntennaTuning(void)
{
	BYTE *dest = (BYTE *)BigBuf;
	int i, ptr = 0, adcval = 0, peak = 0, peakv = 0, peakf = 0;;
	int vLf125 = 0, vLf134 = 0, vHf = 0;	// in mV

	UsbCommand c;

	DbpString("Measuring antenna characteristics, please wait.");
	memset(BigBuf,0,sizeof(BigBuf));

/*
 * Sweeps the useful LF range of the proxmark from
 * 46.8kHz (divisor=255) to 600kHz (divisor=19) and
 * read the voltage in the antenna, the result left
 * in the buffer is a graph which should clearly show
 * the resonating frequency of your LF antenna
 * ( hopefully around 95 if it is tuned to 125kHz!)
 */
	FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_READER);
	for (i=255; i>19; i--) {
		FpgaSendCommand(FPGA_CMD_SET_DIVISOR, i);
		SpinDelay(20);
		// Vref = 3.3V, and a 10000:240 voltage divider on the input
		// can measure voltages up to 137500 mV
		adcval = ((137500 * AvgAdc(ADC_CHAN_LF)) >> 10);
		if (i==95) 	vLf125 = adcval; // voltage at 125Khz
		if (i==89) 	vLf134 = adcval; // voltage at 134Khz

		dest[i] = adcval>>8; // scale int to fit in byte for graphing purposes
		if(dest[i] > peak) {
			peakv = adcval;
			peak = dest[i];
			peakf = i;
			ptr = i;
		}
	}

	// Let the FPGA drive the high-frequency antenna around 13.56 MHz.
	FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
	SpinDelay(20);
	// Vref = 3300mV, and an 10:1 voltage divider on the input
	// can measure voltages up to 33000 mV
	vHf = (33000 * AvgAdc(ADC_CHAN_HF)) >> 10;

	c.cmd = CMD_MEASURED_ANTENNA_TUNING;
	c.ext1 = (vLf125 << 0) | (vLf134 << 16);
	c.ext2 = vHf;
	c.ext3 = peakf | (peakv << 16);
	UsbSendPacket((BYTE *)&c, sizeof(c));
}

void SimulateTagHfListen(void)
{
	BYTE *dest = (BYTE *)BigBuf;
	int n = sizeof(BigBuf);
	BYTE v = 0;
	int i;
	int p = 0;

	// We're using this mode just so that I can test it out; the simulated
	// tag mode would work just as well and be simpler.
	FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR | FPGA_HF_READER_RX_XCORR_848_KHZ | FPGA_HF_READER_RX_XCORR_SNOOP);

	// We need to listen to the high-frequency, peak-detected path.
	SetAdcMuxFor(GPIO_MUXSEL_HIPKD);

	FpgaSetupSsc();

	i = 0;
	for(;;) {
		if(SSC_STATUS & (SSC_STATUS_TX_READY)) {
			SSC_TRANSMIT_HOLDING = 0xff;
		}
		if(SSC_STATUS & (SSC_STATUS_RX_READY)) {
			BYTE r = (BYTE)SSC_RECEIVE_HOLDING;

			v <<= 1;
			if(r & 1) {
				v |= 1;
			}
			p++;

			if(p >= 8) {
				dest[i] = v;
				v = 0;
				p = 0;
				i++;

				if(i >= n) {
					break;
				}
			}
		}
	}
	DbpString("simulate tag (now type bitsamples)");
}

void ReadMem(int addr)
{
	const DWORD *data = ((DWORD *)addr);
	int i;

	DbpString("Reading memory at address");
	DbpIntegers(0, 0, addr);
	for (i = 0; i < 8; i+= 2)
		DbpIntegers(0, data[i], data[i+1]);
}

// samy's sniff and repeat routine
void SamyRun()
{
	DbpString("Stand-alone mode! No PC necessary.");

	// 3 possible options? no just 2 for now
#define OPTS 2

	int high[OPTS], low[OPTS];

	// Oooh pretty -- notify user we're in elite samy mode now
	LED(LED_RED,	200);
	LED(LED_ORANGE, 200);
	LED(LED_GREEN,	200);
	LED(LED_ORANGE, 200);
	LED(LED_RED,	200);
	LED(LED_ORANGE, 200);
	LED(LED_GREEN,	200);
	LED(LED_ORANGE, 200);
	LED(LED_RED,	200);

	int selected = 0;
	int playing = 0;

	// Turn on selected LED
	LED(selected + 1, 0);

	for (;;)
	{
		UsbPoll(FALSE);
		WDT_HIT();

		// Was our button held down or pressed?
		int button_pressed = BUTTON_HELD(1000);
		SpinDelay(300);

		// Button was held for a second, begin recording
		if (button_pressed > 0)
		{
			LEDsoff();
			LED(selected + 1, 0);
			LED(LED_RED2, 0);

			// record
			DbpString("Starting recording");

			// wait for button to be released
			while(BUTTON_PRESS())
				WDT_HIT();

			/* need this delay to prevent catching some weird data */
			SpinDelay(500);

			CmdHIDdemodFSK(1, &high[selected], &low[selected], 0);
			DbpString("Recorded");
			DbpIntegers(selected, high[selected], low[selected]);

			LEDsoff();
			LED(selected + 1, 0);
			// Finished recording

			// If we were previously playing, set playing off
			// so next button push begins playing what we recorded
			playing = 0;
		}

		// Change where to record (or begin playing)
		else if (button_pressed)
		{
			// Next option if we were previously playing
			if (playing)
				selected = (selected + 1) % OPTS;
			playing = !playing;

			LEDsoff();
			LED(selected + 1, 0);

			// Begin transmitting
			if (playing)
			{
				LED(LED_GREEN, 0);
				DbpString("Playing");
				// wait for button to be released
				while(BUTTON_PRESS())
					WDT_HIT();
				DbpIntegers(selected, high[selected], low[selected]);
				CmdHIDsimTAG(high[selected], low[selected], 0);
				DbpString("Done playing");
				if (BUTTON_HELD(1000) > 0)
					{
					DbpString("Exiting");
					LEDsoff();
					return;
					}

				/* We pressed a button so ignore it here with a delay */
				SpinDelay(300);

				// when done, we're done playing, move to next option
				selected = (selected + 1) % OPTS;
				playing = !playing;
				LEDsoff();
				LED(selected + 1, 0);
			}
			else
				while(BUTTON_PRESS())
					WDT_HIT();
		}
	}
}


/*
OBJECTIVE
Listen and detect an external reader. Determine the best location
for the antenna.

INSTRUCTIONS:
Inside the ListenReaderField() function, there is two mode.
By default, when you call the function, you will enter mode 1.
If you press the PM3 button one time, you will enter mode 2.
If you press the PM3 button a second time, you will exit the function.

DESCRIPTION OF MODE 1:
This mode just listens for an external reader field and lights up green
for HF and/or red for LF. This is the original mode of the detectreader
function.

DESCRIPTION OF MODE 2:
This mode will visually represent, using the LEDs, the actual strength of the
current compared to the maximum current detected. Basically, once you know
what kind of external reader is present, it will help you spot the best location to place
your antenna. You will probably not get some good results if there is a LF and a HF reader
at the same place! :-)

LIGHT SCHEME USED:

Light scheme | Descriptiong
----------------------------------------------------
    ----     | No field detected
    X---     | 14% of maximum current detected
    -X--     | 29% of maximum current detected
    --X-     | 43% of maximum current detected
    ---X     | 57% of maximum current detected
    --XX     | 71% of maximum current detected
    -XXX     | 86% of maximum current detected
    XXXX     | 100% of maximum current detected

TODO:
Add the LF part for MODE 2

*/
void ListenReaderField(int limit)
{
	int lf_av, lf_av_new, lf_baseline= 0, lf_count= 0;
	int hf_av, hf_av_new,  hf_baseline= 0, hf_count= 0, hf_max;
	int mode=1;

#define LF_ONLY		1
#define HF_ONLY		2

	LED_A_OFF();
	LED_B_OFF();
	LED_C_OFF();
	LED_D_OFF();

	lf_av= ReadAdc(ADC_CHAN_LF);

	if(limit != HF_ONLY)
		{
		DbpString("LF 125/134 Baseline:");
		DbpIntegers(lf_av,0,0);
		lf_baseline= lf_av;
		}

	hf_av=hf_max=ReadAdc(ADC_CHAN_HF);

	if (limit != LF_ONLY)
		{
		DbpString("HF 13.56 Baseline:");
		DbpIntegers(hf_av,0,0);
		hf_baseline= hf_av;
		}

	for(;;)
		{
		if (BUTTON_PRESS()) {
			SpinDelay(500);
			switch (mode) {
				case 1:
					mode=2;
					DbpString("Signal Strength Mode");
					break;
				case 2:
				default:
					DbpString("Stopped");
					LED_A_OFF();
					LED_B_OFF();
					LED_C_OFF();
					LED_D_OFF();
					return;
					break;
			}
		}
		WDT_HIT();

		if (limit != HF_ONLY)
			{
			if (abs(lf_av - lf_baseline) > 10)
				LED_D_ON();
			else
				LED_D_OFF();
			++lf_count;
			lf_av_new= ReadAdc(ADC_CHAN_LF);
			// see if there's a significant change
			if(abs(lf_av - lf_av_new) > 10)
				{
				DbpString("LF 125/134 Field Change:");
				DbpIntegers(lf_av,lf_av_new,lf_count);
				lf_av= lf_av_new;
				lf_count= 0;
				}
			}

		if (limit != LF_ONLY)
			{
			if (abs(hf_av - hf_baseline) > 10) {
				if (mode == 1)
					LED_B_ON();
				if (mode == 2) {
					if ( hf_av>(hf_max/7)*6) {
						LED_A_ON();	LED_B_ON();	LED_C_ON();	LED_D_ON();
					}
					if ( (hf_av>(hf_max/7)*5) && (hf_av<=(hf_max/7)*6) ) {
						LED_A_ON();	LED_B_ON();	LED_C_OFF(); LED_D_ON();
					}
					if ( (hf_av>(hf_max/7)*4) && (hf_av<=(hf_max/7)*5) ) {
						LED_A_OFF(); LED_B_ON(); LED_C_OFF(); LED_D_ON();
					}
					if ( (hf_av>(hf_max/7)*3) && (hf_av<=(hf_max/7)*4) ) {
						LED_A_OFF(); LED_B_OFF(); LED_C_OFF(); LED_D_ON();
					}
					if ( (hf_av>(hf_max/7)*2) && (hf_av<=(hf_max/7)*3) ) {
						LED_A_OFF(); LED_B_ON(); LED_C_OFF(); LED_D_OFF();
					}
					if ( (hf_av>(hf_max/7)*1) && (hf_av<=(hf_max/7)*2) ) {
						LED_A_ON();	LED_B_OFF(); LED_C_OFF(); LED_D_OFF();
					}
					if ( (hf_av>(hf_max/7)*0) && (hf_av<=(hf_max/7)*1) ) {
						LED_A_OFF(); LED_B_OFF(); LED_C_ON(); LED_D_OFF();
					}
				}
			} else {
				if (mode == 1) {
					LED_B_OFF();
				}
				if (mode == 2) {
					LED_A_OFF(); LED_B_OFF(); LED_C_OFF(); LED_D_OFF();
				}
			}

			++hf_count;
			hf_av_new= ReadAdc(ADC_CHAN_HF);
			// see if there's a significant change
			if(abs(hf_av - hf_av_new) > 10)
				{
				DbpString("HF 13.56 Field Change:");
				DbpIntegers(hf_av,hf_av_new,hf_count);
				hf_av= hf_av_new;
				if (hf_av > hf_max)
					hf_max = hf_av;
				hf_count= 0;
				}
			}
		}
}

void UsbPacketReceived(BYTE *packet, int len)
{
	UsbCommand *c = (UsbCommand *)packet;

	switch(c->cmd) {
		case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
			AcquireRawAdcSamples125k(c->ext1);
			break;

		case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
			ModThenAcquireRawAdcSamples125k(c->ext1,c->ext2,c->ext3,c->d.asBytes);
			break;

		case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693:
			AcquireRawAdcSamplesIso15693();
			break;

		case CMD_BUFF_CLEAR:
			BufferClear();
			break;

		case CMD_READER_ISO_15693:
			ReaderIso15693(c->ext1);
			break;

		case CMD_SIMTAG_ISO_15693:
			SimTagIso15693(c->ext1);
			break;

		case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443:
			AcquireRawAdcSamplesIso14443(c->ext1);
			break;

		case CMD_READ_SRI512_TAG:
			ReadSRI512Iso14443(c->ext1);
			break;

		case CMD_READER_ISO_14443a:
			ReaderIso14443a(c->ext1);
			break;

		case CMD_SNOOP_ISO_14443:
			SnoopIso14443();
			break;

		case CMD_SNOOP_ISO_14443a:
			SnoopIso14443a();
			break;

		case CMD_SIMULATE_TAG_HF_LISTEN:
			SimulateTagHfListen();
			break;

		case CMD_SIMULATE_TAG_ISO_14443:
			SimulateIso14443Tag();
			break;

		case CMD_SIMULATE_TAG_ISO_14443a:
			SimulateIso14443aTag(c->ext1, c->ext2);  // ## Simulate iso14443a tag - pass tag type & UID
			break;

		case CMD_MEASURE_ANTENNA_TUNING:
			MeasureAntennaTuning();
			break;

		case CMD_LISTEN_READER_FIELD:
			ListenReaderField(c->ext1);
			break;

		case CMD_HID_DEMOD_FSK:
			CmdHIDdemodFSK(0, 0, 0, 1);				// Demodulate HID tag
			break;

		case CMD_HID_SIM_TAG:
			CmdHIDsimTAG(c->ext1, c->ext2, 1);					// Simulate HID tag by ID
			break;

		case CMD_FPGA_MAJOR_MODE_OFF:		// ## FPGA Control
			FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
			SpinDelay(200);
			LED_D_OFF(); // LED D indicates field ON or OFF
			break;

		case CMD_READ_TI_TYPE:
			ReadTItag();
			break;

		case CMD_WRITE_TI_TYPE:
			WriteTItag(c->ext1,c->ext2,c->ext3);
			break;

		case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K: {
			UsbCommand n;
			if(c->cmd == CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K) {
				n.cmd = CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K;
			} else {
				n.cmd = CMD_DOWNLOADED_RAW_BITS_TI_TYPE;
			}
			n.ext1 = c->ext1;
			memcpy(n.d.asDwords, BigBuf+c->ext1, 12*sizeof(DWORD));
			UsbSendPacket((BYTE *)&n, sizeof(n));
			break;
		}
		case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
			BYTE *b = (BYTE *)BigBuf;
			memcpy(b+c->ext1, c->d.asBytes, 48);
			break;
		}
		case CMD_SIMULATE_TAG_125K:
			LED_A_ON();
			SimulateTagLowFrequency(c->ext1, 1);
			LED_A_OFF();
			break;
		case CMD_READ_MEM:
			ReadMem(c->ext1);
			break;
		case CMD_SET_LF_DIVISOR:
			FpgaSendCommand(FPGA_CMD_SET_DIVISOR, c->ext1);
			break;
#ifdef WITH_LCD
		case CMD_LCD_RESET:
			LCDReset();
			break;
		case CMD_LCD:
			LCDSend(c->ext1);
			break;
#endif
		case CMD_SETUP_WRITE:
		case CMD_FINISH_WRITE:
		case CMD_HARDWARE_RESET:
			USB_D_PLUS_PULLUP_OFF();
			SpinDelay(1000);
			SpinDelay(1000);
			RSTC_CONTROL = RST_CONTROL_KEY | RST_CONTROL_PROCESSOR_RESET;
			for(;;) {
				// We're going to reset, and the bootrom will take control.
			}
			break;

		default:
			DbpString("unknown command");
			break;
	}
}

void AppMain(void)
{
	memset(BigBuf,0,sizeof(BigBuf));
	SpinDelay(100);

	LED_D_OFF();
	LED_C_OFF();
	LED_B_OFF();
	LED_A_OFF();

	UsbStart();

	// The FPGA gets its clock from us from PCK0 output, so set that up.
	PIO_PERIPHERAL_B_SEL = (1 << GPIO_PCK0);
	PIO_DISABLE = (1 << GPIO_PCK0);
	PMC_SYS_CLK_ENABLE = PMC_SYS_CLK_PROGRAMMABLE_CLK_0;
	// PCK0 is PLL clock / 4 = 96Mhz / 4 = 24Mhz
	PMC_PROGRAMMABLE_CLK_0 = PMC_CLK_SELECTION_PLL_CLOCK |
		PMC_CLK_PRESCALE_DIV_4;
	PIO_OUTPUT_ENABLE = (1 << GPIO_PCK0);

	// Reset SPI
	SPI_CONTROL = SPI_CONTROL_RESET;
	// Reset SSC
	SSC_CONTROL = SSC_CONTROL_RESET;

	// Load the FPGA image, which we have stored in our flash.
	FpgaDownloadAndGo();

#ifdef WITH_LCD

	LCDInit();

	// test text on different colored backgrounds
	LCDString(" The quick brown fox  ",	&FONT6x8,1,1+8*0,WHITE  ,BLACK );
	LCDString("  jumped over the     ",	&FONT6x8,1,1+8*1,BLACK  ,WHITE );
	LCDString("     lazy dog.        ",	&FONT6x8,1,1+8*2,YELLOW ,RED   );
	LCDString(" AaBbCcDdEeFfGgHhIiJj ",	&FONT6x8,1,1+8*3,RED    ,GREEN );
	LCDString(" KkLlMmNnOoPpQqRrSsTt ",	&FONT6x8,1,1+8*4,MAGENTA,BLUE  );
	LCDString("UuVvWwXxYyZz0123456789",	&FONT6x8,1,1+8*5,BLUE   ,YELLOW);
	LCDString("`-=[]_;',./~!@#$%^&*()",	&FONT6x8,1,1+8*6,BLACK  ,CYAN  );
	LCDString("     _+{}|:\\\"<>?     ",&FONT6x8,1,1+8*7,BLUE  ,MAGENTA);

	// color bands
	LCDFill(0, 1+8* 8, 132, 8, BLACK);
	LCDFill(0, 1+8* 9, 132, 8, WHITE);
	LCDFill(0, 1+8*10, 132, 8, RED);
	LCDFill(0, 1+8*11, 132, 8, GREEN);
	LCDFill(0, 1+8*12, 132, 8, BLUE);
	LCDFill(0, 1+8*13, 132, 8, YELLOW);
	LCDFill(0, 1+8*14, 132, 8, CYAN);
	LCDFill(0, 1+8*15, 132, 8, MAGENTA);

#endif

	for(;;) {
		UsbPoll(FALSE);
		WDT_HIT();

		if (BUTTON_HELD(1000) > 0)
			SamyRun();
	}
}
Commit	Line	Data
959baa89	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
959baa89	8	#include <proxmark3.h>
7f348042	9	#include <stdlib.h>
959baa89	10	#include "apps.h"
	11	#ifdef WITH_LCD
	12	#include "fonts.h"
	13	#include "LCD.h"
	14	#endif
	15
959baa89	16
	17	//=============================================================================
	18	// A buffer where we can queue things up to be sent through the FPGA, for
	19	// any purpose (fake tag, as reader, whatever). We go MSB first, since that
	20	// is the order in which they go out on the wire.
	21	//=============================================================================
	22
	23	BYTE ToSend[256];
	24	int ToSendMax;
	25	static int ToSendBit;
	26
f23e056d	27	void BufferClear(void)
	28	{
	29	memset(BigBuf,0,sizeof(BigBuf));
	30	DbpString("Buffer cleared");
	31	}
	32
959baa89	33	void ToSendReset(void)
	34	{
	35	ToSendMax = -1;
	36	ToSendBit = 8;
	37	}
	38
	39	void ToSendStuffBit(int b)
	40	{
	41	if(ToSendBit >= 8) {
	42	ToSendMax++;
	43	ToSend[ToSendMax] = 0;
	44	ToSendBit = 0;
	45	}
	46
	47	if(b) {
	48	ToSend[ToSendMax] \|= (1 << (7 - ToSendBit));
	49	}
	50
	51	ToSendBit++;
	52
	53	if(ToSendBit >= sizeof(ToSend)) {
	54	ToSendBit = 0;
	55	DbpString("ToSendStuffBit overflowed!");
	56	}
	57	}
	58
	59	//=============================================================================
	60	// Debug print functions, to go out over USB, to the usual PC-side client.
	61	//=============================================================================
	62
	63	void DbpString(char *str)
	64	{
955fc5e2	65	/* this holds up stuff unless we're connected to usb */
50722269	66	if (!UsbConnected())
50722269	67	return;
c701d2c2	68
959baa89	69	UsbCommand c;
	70	c.cmd = CMD_DEBUG_PRINT_STRING;
	71	c.ext1 = strlen(str);
	72	memcpy(c.d.asBytes, str, c.ext1);
	73
	74	UsbSendPacket((BYTE *)&c, sizeof(c));
	75	// TODO fix USB so stupid things like this aren't req'd
	76	SpinDelay(50);
	77	}
	78
	79	void DbpIntegers(int x1, int x2, int x3)
	80	{
955fc5e2	81	/* this holds up stuff unless we're connected to usb */
50722269	82	if (!UsbConnected())
50722269	83	return;
955fc5e2	84
959baa89	85	UsbCommand c;
	86	c.cmd = CMD_DEBUG_PRINT_INTEGERS;
	87	c.ext1 = x1;
	88	c.ext2 = x2;
	89	c.ext3 = x3;
	90
	91	UsbSendPacket((BYTE *)&c, sizeof(c));
	92	// XXX
	93	SpinDelay(50);
	94	}
	95
959baa89	96	//-----------------------------------------------------------------------------
	97	// Read an ADC channel and block till it completes, then return the result
	98	// in ADC units (0 to 1023). Also a routine to average 32 samples and
	99	// return that.
	100	//-----------------------------------------------------------------------------
	101	static int ReadAdc(int ch)
	102	{
	103	DWORD d;
	104
	105	ADC_CONTROL = ADC_CONTROL_RESET;
	106	ADC_MODE = ADC_MODE_PRESCALE(32) \| ADC_MODE_STARTUP_TIME(16) \|
	107	ADC_MODE_SAMPLE_HOLD_TIME(8);
	108	ADC_CHANNEL_ENABLE = ADC_CHANNEL(ch);
	109
	110	ADC_CONTROL = ADC_CONTROL_START;
	111	while(!(ADC_STATUS & ADC_END_OF_CONVERSION(ch)))
	112	;
	113	d = ADC_CHANNEL_DATA(ch);
	114
	115	return d;
	116	}
	117
	118	static int AvgAdc(int ch)
	119	{
	120	int i;
	121	int a = 0;
	122
	123	for(i = 0; i < 32; i++) {
	124	a += ReadAdc(ch);
	125	}
	126
	127	return (a + 15) >> 5;
	128	}
30f2a7d3	129
e7aee94e	130	void MeasureAntennaTuning(void)
959baa89	131	{
959baa89	132	BYTE dest = (BYTE )BigBuf;
e7aee94e	133	int i, ptr = 0, adcval = 0, peak = 0, peakv = 0, peakf = 0;;
	134	int vLf125 = 0, vLf134 = 0, vHf = 0; // in mV
	135
	136	UsbCommand c;
959baa89	137
e7aee94e	138	DbpString("Measuring antenna characteristics, please wait.");
959baa89	139	memset(BigBuf,0,sizeof(BigBuf));
959baa89	140
e7aee94e	141	/*
	142	* Sweeps the useful LF range of the proxmark from
	143	* 46.8kHz (divisor=255) to 600kHz (divisor=19) and
	144	* read the voltage in the antenna, the result left
	145	* in the buffer is a graph which should clearly show
	146	* the resonating frequency of your LF antenna
	147	* ( hopefully around 95 if it is tuned to 125kHz!)
	148	*/
959baa89	149	FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_READER);
	150	for (i=255; i>19; i--) {
	151	FpgaSendCommand(FPGA_CMD_SET_DIVISOR, i);
	152	SpinDelay(20);
e7aee94e	153	// Vref = 3.3V, and a 10000:240 voltage divider on the input
	154	// can measure voltages up to 137500 mV
	155	adcval = ((137500 * AvgAdc(ADC_CHAN_LF)) >> 10);
	156	if (i==95) vLf125 = adcval; // voltage at 125Khz
	157	if (i==89) vLf134 = adcval; // voltage at 134Khz
	158
	159	dest[i] = adcval>>8; // scale int to fit in byte for graphing purposes
38b65694	160	if(dest[i] > peak) {
e7aee94e	161	peakv = adcval;
	162	peak = dest[i];
	163	peakf = i;
	164	ptr = i;
38b65694	165	}
e7aee94e	166	}
959baa89	167
	168	// Let the FPGA drive the high-frequency antenna around 13.56 MHz.
	169	FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
	170	SpinDelay(20);
959baa89	171	// Vref = 3300mV, and an 10:1 voltage divider on the input
959baa89	172	// can measure voltages up to 33000 mV
e7aee94e	173	vHf = (33000 * AvgAdc(ADC_CHAN_HF)) >> 10;
959baa89	174
	175	c.cmd = CMD_MEASURED_ANTENNA_TUNING;
	176	c.ext1 = (vLf125 << 0) \| (vLf134 << 16);
	177	c.ext2 = vHf;
c701d2c2	178	c.ext3 = peakf \| (peakv << 16);
959baa89	179	UsbSendPacket((BYTE *)&c, sizeof(c));
	180	}
	181
9bea179a	182	void SimulateTagHfListen(void)
959baa89	183	{
9bea179a	184	BYTE dest = (BYTE )BigBuf;
	185	int n = sizeof(BigBuf);
	186	BYTE v = 0;
959baa89	187	int i;
9bea179a	188	int p = 0;
959baa89	189
9bea179a	190	// We're using this mode just so that I can test it out; the simulated
	191	// tag mode would work just as well and be simpler.
	192	FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR \| FPGA_HF_READER_RX_XCORR_848_KHZ \| FPGA_HF_READER_RX_XCORR_SNOOP);
959baa89	193
9bea179a	194	// We need to listen to the high-frequency, peak-detected path.
9bea179a	195	SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
959baa89	196
9bea179a	197	FpgaSetupSsc();
959baa89	198
	199	i = 0;
	200	for(;;) {
9bea179a	201	if(SSC_STATUS & (SSC_STATUS_TX_READY)) {
9bea179a	202	SSC_TRANSMIT_HOLDING = 0xff;
959baa89	203	}
9bea179a	204	if(SSC_STATUS & (SSC_STATUS_RX_READY)) {
9bea179a	205	BYTE r = (BYTE)SSC_RECEIVE_HOLDING;
959baa89	206
9bea179a	207	v <<= 1;
	208	if(r & 1) {
	209	v \|= 1;
	210	}
	211	p++;
c701d2c2	212
9bea179a	213	if(p >= 8) {
	214	dest[i] = v;
	215	v = 0;
	216	p = 0;
	217	i++;
959baa89	218
9bea179a	219	if(i >= n) {
	220	break;
	221	}
959baa89	222	}
959baa89	223	}
959baa89	224	}
9bea179a	225	DbpString("simulate tag (now type bitsamples)");
959baa89	226	}
959baa89	227
9bea179a	228	void ReadMem(int addr)
	229	{
	230	const DWORD data = ((DWORD )addr);
	231	int i;
959baa89	232
9bea179a	233	DbpString("Reading memory at address");
	234	DbpIntegers(0, 0, addr);
	235	for (i = 0; i < 8; i+= 2)
	236	DbpIntegers(0, data[i], data[i+1]);
959baa89	237	}
959baa89	238
9bea179a	239	// samy's sniff and repeat routine
9bea179a	240	void SamyRun()
959baa89	241	{
9bea179a	242	DbpString("Stand-alone mode! No PC necessary.");
959baa89	243
9bea179a	244	// 3 possible options? no just 2 for now
9bea179a	245	#define OPTS 2
959baa89	246
9bea179a	247	int high[OPTS], low[OPTS];
c701d2c2	248
9bea179a	249	// Oooh pretty -- notify user we're in elite samy mode now
	250	LED(LED_RED, 200);
	251	LED(LED_ORANGE, 200);
	252	LED(LED_GREEN, 200);
	253	LED(LED_ORANGE, 200);
	254	LED(LED_RED, 200);
	255	LED(LED_ORANGE, 200);
	256	LED(LED_GREEN, 200);
	257	LED(LED_ORANGE, 200);
	258	LED(LED_RED, 200);
959baa89	259
9bea179a	260	int selected = 0;
9bea179a	261	int playing = 0;
959baa89	262
9bea179a	263	// Turn on selected LED
9bea179a	264	LED(selected + 1, 0);
959baa89	265
9bea179a	266	for (;;)
9bea179a	267	{
50722269	268	UsbPoll(FALSE);
9bea179a	269	WDT_HIT();
959baa89	270
9bea179a	271	// Was our button held down or pressed?
	272	int button_pressed = BUTTON_HELD(1000);
	273	SpinDelay(300);
959baa89	274
9bea179a	275	// Button was held for a second, begin recording
	276	if (button_pressed > 0)
	277	{
	278	LEDsoff();
	279	LED(selected + 1, 0);
	280	LED(LED_RED2, 0);
959baa89	281
9bea179a	282	// record
9bea179a	283	DbpString("Starting recording");
959baa89	284
9bea179a	285	// wait for button to be released
	286	while(BUTTON_PRESS())
	287	WDT_HIT();
959baa89	288
9bea179a	289	/* need this delay to prevent catching some weird data */
9bea179a	290	SpinDelay(500);
959baa89	291
9bea179a	292	CmdHIDdemodFSK(1, &high[selected], &low[selected], 0);
	293	DbpString("Recorded");
	294	DbpIntegers(selected, high[selected], low[selected]);
959baa89	295
9bea179a	296	LEDsoff();
	297	LED(selected + 1, 0);
	298	// Finished recording
959baa89	299
9bea179a	300	// If we were previously playing, set playing off
	301	// so next button push begins playing what we recorded
	302	playing = 0;
959baa89	303	}
959baa89	304
9bea179a	305	// Change where to record (or begin playing)
	306	else if (button_pressed)
	307	{
	308	// Next option if we were previously playing
	309	if (playing)
	310	selected = (selected + 1) % OPTS;
	311	playing = !playing;
959baa89	312
9bea179a	313	LEDsoff();
	314	LED(selected + 1, 0);
	315
	316	// Begin transmitting
	317	if (playing)
959baa89	318	{
9bea179a	319	LED(LED_GREEN, 0);
	320	DbpString("Playing");
	321	// wait for button to be released
	322	while(BUTTON_PRESS())
	323	WDT_HIT();
	324	DbpIntegers(selected, high[selected], low[selected]);
	325	CmdHIDsimTAG(high[selected], low[selected], 0);
	326	DbpString("Done playing");
	327	if (BUTTON_HELD(1000) > 0)
955fc5e2	328	{
9bea179a	329	DbpString("Exiting");
	330	LEDsoff();
	331	return;
955fc5e2	332	}
9bea179a	333
	334	/* We pressed a button so ignore it here with a delay */
	335	SpinDelay(300);
	336
	337	// when done, we're done playing, move to next option
	338	selected = (selected + 1) % OPTS;
	339	playing = !playing;
	340	LEDsoff();
	341	LED(selected + 1, 0);
959baa89	342	}
9bea179a	343	else
	344	while(BUTTON_PRESS())
	345	WDT_HIT();
959baa89	346	}
959baa89	347	}
	348	}
	349
9bea179a	350
	351	/*
	352	OBJECTIVE
	353	Listen and detect an external reader. Determine the best location
	354	for the antenna.
	355
	356	INSTRUCTIONS:
	357	Inside the ListenReaderField() function, there is two mode.
	358	By default, when you call the function, you will enter mode 1.
	359	If you press the PM3 button one time, you will enter mode 2.
	360	If you press the PM3 button a second time, you will exit the function.
	361
	362	DESCRIPTION OF MODE 1:
	363	This mode just listens for an external reader field and lights up green
	364	for HF and/or red for LF. This is the original mode of the detectreader
	365	function.
	366
	367	DESCRIPTION OF MODE 2:
	368	This mode will visually represent, using the LEDs, the actual strength of the
	369	current compared to the maximum current detected. Basically, once you know
	370	what kind of external reader is present, it will help you spot the best location to place
	371	your antenna. You will probably not get some good results if there is a LF and a HF reader
	372	at the same place! :-)
	373
	374	LIGHT SCHEME USED:
	375
	376	Light scheme \| Descriptiong
	377	----------------------------------------------------
	378	---- \| No field detected
	379	X--- \| 14% of maximum current detected
	380	-X-- \| 29% of maximum current detected
	381	--X- \| 43% of maximum current detected
	382	---X \| 57% of maximum current detected
	383	--XX \| 71% of maximum current detected
	384	-XXX \| 86% of maximum current detected
	385	XXXX \| 100% of maximum current detected
	386
	387	TODO:
	388	Add the LF part for MODE 2
	389
	390	*/
	391	void ListenReaderField(int limit)
959baa89	392	{
9bea179a	393	int lf_av, lf_av_new, lf_baseline= 0, lf_count= 0;
	394	int hf_av, hf_av_new, hf_baseline= 0, hf_count= 0, hf_max;
	395	int mode=1;
959baa89	396
9bea179a	397	#define LF_ONLY 1
9bea179a	398	#define HF_ONLY 2
959baa89	399
9bea179a	400	LED_A_OFF();
	401	LED_B_OFF();
	402	LED_C_OFF();
	403	LED_D_OFF();
959baa89	404
9bea179a	405	lf_av= ReadAdc(ADC_CHAN_LF);
959baa89	406
9bea179a	407	if(limit != HF_ONLY)
	408	{
	409	DbpString("LF 125/134 Baseline:");
	410	DbpIntegers(lf_av,0,0);
	411	lf_baseline= lf_av;
959baa89	412	}
959baa89	413
9bea179a	414	hf_av=hf_max=ReadAdc(ADC_CHAN_HF);
959baa89	415
9bea179a	416	if (limit != LF_ONLY)
	417	{
	418	DbpString("HF 13.56 Baseline:");
	419	DbpIntegers(hf_av,0,0);
	420	hf_baseline= hf_av;
	421	}
959baa89	422
9bea179a	423	for(;;)
	424	{
	425	if (BUTTON_PRESS()) {
	426	SpinDelay(500);
	427	switch (mode) {
	428	case 1:
	429	mode=2;
	430	DbpString("Signal Strength Mode");
959baa89	431	break;
9bea179a	432	case 2:
	433	default:
	434	DbpString("Stopped");
	435	LED_A_OFF();
	436	LED_B_OFF();
	437	LED_C_OFF();
	438	LED_D_OFF();
	439	return;
	440	break;
	441	}
	442	}
	443	WDT_HIT();
	444
	445	if (limit != HF_ONLY)
	446	{
	447	if (abs(lf_av - lf_baseline) > 10)
	448	LED_D_ON();
	449	else
	450	LED_D_OFF();
	451	++lf_count;
	452	lf_av_new= ReadAdc(ADC_CHAN_LF);
	453	// see if there's a significant change
	454	if(abs(lf_av - lf_av_new) > 10)
	455	{
	456	DbpString("LF 125/134 Field Change:");
	457	DbpIntegers(lf_av,lf_av_new,lf_count);
	458	lf_av= lf_av_new;
	459	lf_count= 0;
	460	}
	461	}
	462
	463	if (limit != LF_ONLY)
	464	{
	465	if (abs(hf_av - hf_baseline) > 10) {
	466	if (mode == 1)
	467	LED_B_ON();
	468	if (mode == 2) {
	469	if ( hf_av>(hf_max/7)*6) {
	470	LED_A_ON(); LED_B_ON(); LED_C_ON(); LED_D_ON();
	471	}
	472	if ( (hf_av>(hf_max/7)5) && (hf_av<=(hf_max/7)6) ) {
	473	LED_A_ON(); LED_B_ON(); LED_C_OFF(); LED_D_ON();
	474	}
	475	if ( (hf_av>(hf_max/7)4) && (hf_av<=(hf_max/7)5) ) {
	476	LED_A_OFF(); LED_B_ON(); LED_C_OFF(); LED_D_ON();
	477	}
	478	if ( (hf_av>(hf_max/7)3) && (hf_av<=(hf_max/7)4) ) {
	479	LED_A_OFF(); LED_B_OFF(); LED_C_OFF(); LED_D_ON();
	480	}
	481	if ( (hf_av>(hf_max/7)2) && (hf_av<=(hf_max/7)3) ) {
	482	LED_A_OFF(); LED_B_ON(); LED_C_OFF(); LED_D_OFF();
	483	}
	484	if ( (hf_av>(hf_max/7)1) && (hf_av<=(hf_max/7)2) ) {
	485	LED_A_ON(); LED_B_OFF(); LED_C_OFF(); LED_D_OFF();
	486	}
	487	if ( (hf_av>(hf_max/7)0) && (hf_av<=(hf_max/7)1) ) {
	488	LED_A_OFF(); LED_B_OFF(); LED_C_ON(); LED_D_OFF();
	489	}
	490	}
	491	} else {
	492	if (mode == 1) {
	493	LED_B_OFF();
	494	}
	495	if (mode == 2) {
496	LED_A_OFF(); LED_B_OFF(); LED_C_OFF(); LED_D_OFF();
497	}
498	}
499
500	++hf_count;
501	hf_av_new= ReadAdc(ADC_CHAN_HF);
502	// see if there's a significant change
503	if(abs(hf_av - hf_av_new) > 10)
504	{
505	DbpString("HF 13.56 Field Change:");
506	DbpIntegers(hf_av,hf_av_new,hf_count);
507	hf_av= hf_av_new;
508	if (hf_av > hf_max)
509	hf_max = hf_av;
510	hf_count= 0;
959baa89	511	}
	512	}
	513	}
959baa89	514	}
	515
	516	void UsbPacketReceived(BYTE *packet, int len)
	517	{
	518	UsbCommand c = (UsbCommand )packet;
	519
	520	switch(c->cmd) {
	521	case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
	522	AcquireRawAdcSamples125k(c->ext1);
	523	break;
	524
	525	case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
	526	ModThenAcquireRawAdcSamples125k(c->ext1,c->ext2,c->ext3,c->d.asBytes);
	527	break;
	528
	529	case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693:
	530	AcquireRawAdcSamplesIso15693();
	531	break;
f23e056d	532
	533	case CMD_BUFF_CLEAR:
	534	BufferClear();
	535	break;
959baa89	536
	537	case CMD_READER_ISO_15693:
	538	ReaderIso15693(c->ext1);
	539	break;
	540
	541	case CMD_SIMTAG_ISO_15693:
	542	SimTagIso15693(c->ext1);
	543	break;
	544
	545	case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443:
	546	AcquireRawAdcSamplesIso14443(c->ext1);
	547	break;
fb25b483	548
	549	case CMD_READ_SRI512_TAG:
	550	ReadSRI512Iso14443(c->ext1);
	551	break;
959baa89	552
	553	case CMD_READER_ISO_14443a:
	554	ReaderIso14443a(c->ext1);
	555	break;
	556
	557	case CMD_SNOOP_ISO_14443:
	558	SnoopIso14443();
	559	break;
	560
	561	case CMD_SNOOP_ISO_14443a:
	562	SnoopIso14443a();
	563	break;
	564
	565	case CMD_SIMULATE_TAG_HF_LISTEN:
	566	SimulateTagHfListen();
	567	break;
	568
	569	case CMD_SIMULATE_TAG_ISO_14443:
	570	SimulateIso14443Tag();
	571	break;
	572
	573	case CMD_SIMULATE_TAG_ISO_14443a:
	574	SimulateIso14443aTag(c->ext1, c->ext2); // ## Simulate iso14443a tag - pass tag type & UID
	575	break;
	576
	577	case CMD_MEASURE_ANTENNA_TUNING:
	578	MeasureAntennaTuning();
	579	break;
	580
7f348042	581	case CMD_LISTEN_READER_FIELD:
	582	ListenReaderField(c->ext1);
	583	break;
	584
959baa89	585	case CMD_HID_DEMOD_FSK:
955fc5e2	586	CmdHIDdemodFSK(0, 0, 0, 1); // Demodulate HID tag
959baa89	587	break;
	588
	589	case CMD_HID_SIM_TAG:
955fc5e2	590	CmdHIDsimTAG(c->ext1, c->ext2, 1); // Simulate HID tag by ID
959baa89	591	break;
	592
	593	case CMD_FPGA_MAJOR_MODE_OFF: // ## FPGA Control
	594	FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
	595	SpinDelay(200);
	596	LED_D_OFF(); // LED D indicates field ON or OFF
	597	break;
	598
9bea179a	599	case CMD_READ_TI_TYPE:
	600	ReadTItag();
	601	break;
	602
	603	case CMD_WRITE_TI_TYPE:
	604	WriteTItag(c->ext1,c->ext2,c->ext3);
	605	break;
	606
7381e8f2	607	case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K: {
959baa89	608	UsbCommand n;
	609	if(c->cmd == CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K) {
	610	n.cmd = CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K;
	611	} else {
	612	n.cmd = CMD_DOWNLOADED_RAW_BITS_TI_TYPE;
	613	}
	614	n.ext1 = c->ext1;
	615	memcpy(n.d.asDwords, BigBuf+c->ext1, 12*sizeof(DWORD));
	616	UsbSendPacket((BYTE *)&n, sizeof(n));
	617	break;
	618	}
	619	case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
	620	BYTE b = (BYTE )BigBuf;
	621	memcpy(b+c->ext1, c->d.asBytes, 48);
	622	break;
	623	}
	624	case CMD_SIMULATE_TAG_125K:
	625	LED_A_ON();
955fc5e2	626	SimulateTagLowFrequency(c->ext1, 1);
959baa89	627	LED_A_OFF();
959baa89	628	break;
1dff8c42	629	case CMD_READ_MEM:
	630	ReadMem(c->ext1);
	631	break;
959baa89	632	case CMD_SET_LF_DIVISOR:
	633	FpgaSendCommand(FPGA_CMD_SET_DIVISOR, c->ext1);
	634	break;
	635	#ifdef WITH_LCD
7381e8f2	636	case CMD_LCD_RESET:
	637	LCDReset();
	638	break;
959baa89	639	case CMD_LCD:
	640	LCDSend(c->ext1);
	641	break;
	642	#endif
9bea179a	643	case CMD_SETUP_WRITE:
959baa89	644	case CMD_FINISH_WRITE:
	645	case CMD_HARDWARE_RESET:
	646	USB_D_PLUS_PULLUP_OFF();
	647	SpinDelay(1000);
	648	SpinDelay(1000);
	649	RSTC_CONTROL = RST_CONTROL_KEY \| RST_CONTROL_PROCESSOR_RESET;
	650	for(;;) {
	651	// We're going to reset, and the bootrom will take control.
	652	}
	653	break;
	654
959baa89	655	default:
	656	DbpString("unknown command");
	657	break;
	658	}
	659	}
	660
	661	void AppMain(void)
	662	{
	663	memset(BigBuf,0,sizeof(BigBuf));
	664	SpinDelay(100);
	665
693f7cf7	666	LED_D_OFF();
	667	LED_C_OFF();
	668	LED_B_OFF();
	669	LED_A_OFF();
959baa89	670
	671	UsbStart();
	672
	673	// The FPGA gets its clock from us from PCK0 output, so set that up.
	674	PIO_PERIPHERAL_B_SEL = (1 << GPIO_PCK0);
	675	PIO_DISABLE = (1 << GPIO_PCK0);
	676	PMC_SYS_CLK_ENABLE = PMC_SYS_CLK_PROGRAMMABLE_CLK_0;
	677	// PCK0 is PLL clock / 4 = 96Mhz / 4 = 24Mhz
	678	PMC_PROGRAMMABLE_CLK_0 = PMC_CLK_SELECTION_PLL_CLOCK \|
	679	PMC_CLK_PRESCALE_DIV_4;
	680	PIO_OUTPUT_ENABLE = (1 << GPIO_PCK0);
	681
	682	// Reset SPI
	683	SPI_CONTROL = SPI_CONTROL_RESET;
	684	// Reset SSC
	685	SSC_CONTROL = SSC_CONTROL_RESET;
	686
	687	// Load the FPGA image, which we have stored in our flash.
	688	FpgaDownloadAndGo();
	689
	690	#ifdef WITH_LCD
	691
	692	LCDInit();
	693
	694	// test text on different colored backgrounds
693f7cf7	695	LCDString(" The quick brown fox ", &FONT6x8,1,1+8*0,WHITE ,BLACK );
	696	LCDString(" jumped over the ", &FONT6x8,1,1+8*1,BLACK ,WHITE );
	697	LCDString(" lazy dog. ", &FONT6x8,1,1+8*2,YELLOW ,RED );
	698	LCDString(" AaBbCcDdEeFfGgHhIiJj ", &FONT6x8,1,1+8*3,RED ,GREEN );
	699	LCDString(" KkLlMmNnOoPpQqRrSsTt ", &FONT6x8,1,1+8*4,MAGENTA,BLUE );
	700	LCDString("UuVvWwXxYyZz0123456789", &FONT6x8,1,1+8*5,BLUE ,YELLOW);
	701	LCDString("`-=[]_;',./~!@#$%^&()", &FONT6x8,1,1+86,BLACK ,CYAN );
	702	LCDString(" _+{}\|:\\\"<>? ",&FONT6x8,1,1+8*7,BLUE ,MAGENTA);
959baa89	703
	704	// color bands
	705	LCDFill(0, 1+8* 8, 132, 8, BLACK);
	706	LCDFill(0, 1+8* 9, 132, 8, WHITE);
	707	LCDFill(0, 1+8*10, 132, 8, RED);
	708	LCDFill(0, 1+8*11, 132, 8, GREEN);
	709	LCDFill(0, 1+8*12, 132, 8, BLUE);
	710	LCDFill(0, 1+8*13, 132, 8, YELLOW);
	711	LCDFill(0, 1+8*14, 132, 8, CYAN);
	712	LCDFill(0, 1+8*15, 132, 8, MAGENTA);
	713
	714	#endif
	715
	716	for(;;) {
50722269	717	UsbPoll(FALSE);
959baa89	718	WDT_HIT();
959baa89	719
955fc5e2	720	if (BUTTON_HELD(1000) > 0)
955fc5e2	721	SamyRun();
959baa89	722	}
959baa89	723	}