source code for all my flash stuff, now finally in cvs


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@4083 a1c6a512-1295-4272-9138-f99709370657
diff --git a/flash/README b/flash/README
index 304360c..9f77dd5 100644
--- a/flash/README
+++ b/flash/README
@@ -1 +1,7 @@
-Readme
+(c) 2003 by Jörg Hohensohn
+
+Sourcecode for the flash "infrastructure"
+Please bear in mind that these are powerful tools, don't fool with them!
+
+For most up-to-date info about flashing see:
+http://rockbox.haxx.se/docs/flash.html
diff --git a/flash/bootloader/Makefile b/flash/bootloader/Makefile
new file mode 100644
index 0000000..ae56cf9
--- /dev/null
+++ b/flash/bootloader/Makefile
@@ -0,0 +1,78 @@
+#             __________               __   ___.
+#   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+#   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+#   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+#   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+#                     \/            \/     \/    \/            \/
+# $Id$
+#
+
+CC = sh-elf-gcc 
+LD = sh-elf-ld
+AR = sh-elf-ar
+AS = sh-elf-as
+OC = sh-elf-objcopy
+
+FIRMWARE := ../../firmware
+TOOLSDIR=../../tools
+
+TARGET = bootloader
+LDS := $(TARGET).lds
+
+
+ifndef PLATFORM 
+not_configured:
+	@echo "No platform given."
+	@echo "Use make PLATFORM=PLAYER|RECORDER|RECORDER|FM {NO_ROM=1}"
+##else
+##configured:
+##	@echo "Building bootloader for platform "$(PLATFORM)
+endif
+
+
+INCLUDES= -I$(FIRMWARE)/export -I. -I$(OBJDIR)
+DEFINES= -DPLATFORM_$(PLATFORM)
+
+OBJDIR := .
+
+CFLAGS = -O -W -Wall -m1 -nostdlib -ffreestanding -Wstrict-prototypes -fomit-frame-pointer -fschedule-insns $(INCLUDES) $(DEFINES)
+AFLAGS += -small -relax
+
+
+ifdef DEBUG
+	DEFINES := -DDEBUG
+	CFLAGS += -g
+endif
+
+SRC := $(wildcard *.c)
+
+OBJS := $(SRC:%.c=$(OBJDIR)/%.o)
+
+ifdef NO_ROM
+LINKFILE = $(OBJDIR)/no_rom.lds
+ORIGIN = 0
+DEFINES += -DNO_ROM
+else
+LINKFILE = $(OBJDIR)/$(TARGET).lds
+ORIGIN = FFFF500
+endif
+
+$(OBJDIR)/$(TARGET).bin : $(OBJDIR)/$(TARGET).elf
+	$(OC) -O binary $(OBJDIR)/$(TARGET).elf $(OBJDIR)/$(TARGET).bin
+	$(TOOLSDIR)/sh2d $(OBJDIR)/$(TARGET).bin -o $(ORIGIN) > $(OBJDIR)/$(TARGET).asm
+ifndef NO_ROM
+	$(TOOLSDIR)/scramble $(OBJDIR)/$(TARGET).bin $(OBJDIR)/$(TARGET).ajz
+endif
+
+$(OBJDIR)/$(TARGET).elf : $(OBJS) 
+	$(CC) -Os -nostdlib -o $(OBJDIR)/$(TARGET).elf -L$(OBJDIR) -T$(LINKFILE) -Wl,-Map,$(OBJDIR)/$(TARGET).map
+
+
+clean:
+	-rm -f \
+	$(OBJS) \
+	$(OBJDIR)/$(TARGET).asm \
+	$(OBJDIR)/$(TARGET).bin \
+	$(OBJDIR)/$(TARGET).ajz \
+	$(OBJDIR)/$(TARGET).elf \
+	$(OBJDIR)/$(TARGET).map
diff --git a/flash/bootloader/README b/flash/bootloader/README
new file mode 100644
index 0000000..16c27d9
--- /dev/null
+++ b/flash/bootloader/README
@@ -0,0 +1,4 @@
+(c) 2003 by Jörg Hohensohn
+
+This is the source code for the flash bootloader.
+It give the dual boot feature, decompresses one of two software images.
diff --git a/flash/bootloader/bootloader.c b/flash/bootloader/bootloader.c
new file mode 100644
index 0000000..7179bbe
--- /dev/null
+++ b/flash/bootloader/bootloader.c
@@ -0,0 +1,480 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2003 by Jörg Hohensohn 
+ * 
+ * Second-level bootloader, with dual-boot feature by holding F1/Menu
+ * This is the image being descrambled and executed by the boot ROM.
+ * It's task is to copy Rockbox from Flash to DRAM.
+ * The image(s) in flash may optionally be compressed with UCL 2e
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include "sh7034.h"
+#include "bootloader.h"
+
+
+#ifdef NO_ROM
+// start with the vector table
+UINT32 vectors[] __attribute__ ((section (".vectors"))) = 
+{
+	(UINT32)_main, // entry point, the copy routine
+	(UINT32)(end_stack - 1), // initial stack pointer
+	FLASH_BASE + 0x200, // source of image in flash
+	(UINT32)total_size, // size of image
+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+	0x03020080 // mask and version (just as a suggestion)
+};
+#else
+// our binary has to start with a vector to the entry point
+tpMain start_vector[] __attribute__ ((section (".startvector"))) = {main};
+#endif
+
+#ifdef NO_ROM // some code which is only needed for the romless variant
+void _main(void)
+{
+	UINT32* pSrc;
+	UINT32* pDest;
+	UINT32* pEnd;
+/*
+	asm volatile ("ldc %0,sr" : : "r"(0xF0)); // disable interrupts
+	asm volatile ("mov.l @%0,r15" : : "r"(4)); // load stack
+	asm volatile ("ldc %0,vbr" : : "r"(0)); // load vector base
+*/
+	// copy everything to IRAM and continue there
+	pSrc = begin_iramcopy;
+	pDest = begin_text;
+	pEnd = pDest + (begin_stack - begin_text);
+
+	do
+	{
+		*pDest++ = *pSrc++;
+	}
+	while (pDest < pEnd);
+
+	main(); // jump to the real main()
+}
+
+
+void BootInit(void)
+{
+	// inits from the boot ROM, whether they make sense or not
+	PBDR &= 0xFFBF; // LED off (0x131E)
+	PBCR2 = 0; // all GPIO
+	PBIOR |= 0x40; // LED output
+	PBIOR &= 0xFFF1; // LCD lines input
+
+	// init DRAM like the boot ROM does
+	PACR2 &= 0xFFFB;
+	PACR2 |= 0x0008;
+	CASCR  = 0xAF;
+	BCR   |= 0x8000;
+	WCR1  &= 0xFDFD;
+	DCR    = 0x0E00;
+	RCR    = 0x5AB0;
+	RTCOR  = 0x9605;
+	RTCSR  = 0xA518;
+}
+#endif // #ifdef NO_ROM
+
+
+int main(void)
+{
+	int nButton;
+
+	PlatformInit(); // model-specific inits
+
+	nButton = ButtonPressed();
+
+	if (nButton == 3)
+	{	// F3 means start monitor
+		MiniMon();
+	}
+	else
+	{
+		tImage* pImage;
+		pImage = GetStartImage(nButton); // which image
+		DecompressStart(pImage); // move into place and start it
+	}
+
+	return 0; // I guess we won't return  ;-)
+}
+
+
+// init code that is specific to certain platform
+void PlatformInit(void)
+{
+#ifdef NO_ROM
+	BootInit(); // if not started by boot ROM, we need to init what it did
+#endif
+
+#if defined PLATFORM_PLAYER
+	BRR1  =  0x0019; // 14400 Baud for monitor
+	if (FW_VERSION > 451) // "new" Player?
+	{
+		PBDR &= ~0x10; // set PB4 to 0 to power-up the harddisk early
+		PBIOR |= 0x10; // make PB4 an output
+	}
+#elif defined PLATFORM_RECORDER
+	BRR1  =  0x0002; // 115200 Baud for monitor
+	if (ReadADC(7) > 0x100) // charger plugged?
+	{	// switch off the HD, else a flat battery may not start
+		PACR2 &= 0xFBFF; // GPIO for PA5
+		PAIOR |= 0x20;	 // make PA5 an output (low by default)
+	}
+#elif defined PLATFORM_FM
+	BRR1  =  0x0002; // 115200 Baud for monitor
+	PBDR |= 0x20; // set PB5 to keep power (fixes the ON-holding problem)
+	PBIOR |= 0x20; // make PB5 an output
+	if (ReadADC(0) < 0x1FF) // charger plugged?
+	{
+		// how do we switch this off?
+	}
+#endif
+
+	// platform-independent inits
+	DCR |= 0x1000; // enable burst mode on DRAM
+	BCR |= 0x2000; // activate Warp mode (simultaneous internal and external mem access)
+}
+
+
+// Thinned out version of the UCL 2e decompression sourcecode
+// Original (C) Markus F.X.J Oberhumer under GNU GPL license
+#define GETBIT(bb, src, ilen) \
+	(((bb = bb & 0x7f ? bb*2 : ((unsigned)src[ilen++]*2+1)) >> 8) & 1) 
+
+int ucl_nrv2e_decompress_8(
+	const UINT8 *src, UINT8 *dst, UINT32* dst_len)
+{ 
+	UINT32 bb = 0;
+	unsigned ilen = 0, olen = 0, last_m_off = 1;
+
+	for (;;)
+	{
+		unsigned m_off, m_len;
+
+		while (GETBIT(bb,src,ilen))
+		{
+			dst[olen++] = src[ilen++];
+		}
+		m_off = 1;
+		for (;;)
+		{
+			m_off = m_off*2 + GETBIT(bb,src,ilen);
+			if (GETBIT(bb,src,ilen)) break;
+			m_off = (m_off-1)*2 + GETBIT(bb,src,ilen);
+		}
+		if (m_off == 2)
+		{
+			m_off = last_m_off;
+			m_len = GETBIT(bb,src,ilen);
+		}
+		else
+		{
+			m_off = (m_off-3)*256 + src[ilen++];
+			if (m_off == 0xffffffff)
+				break;
+			m_len = (m_off ^ 0xffffffff) & 1;
+			m_off >>= 1;
+			last_m_off = ++m_off;
+		}
+		if (m_len)
+			m_len = 1 + GETBIT(bb,src,ilen);
+		else if (GETBIT(bb,src,ilen))
+			m_len = 3 + GETBIT(bb,src,ilen);
+		else
+		{
+			m_len++;
+			do {
+				m_len = m_len*2 + GETBIT(bb,src,ilen);
+			} while (!GETBIT(bb,src,ilen));
+			m_len += 3;
+		}
+		m_len += (m_off > 0x500);
+		{
+			const UINT8 *m_pos;
+			m_pos = dst + olen - m_off;
+			dst[olen++] = *m_pos++;
+			do dst[olen++] = *m_pos++; while (--m_len > 0);
+		}
+	}
+	*dst_len = olen;
+
+	return ilen;
+}
+
+
+// move the image into place and start it
+void DecompressStart(tImage* pImage)
+{
+	UINT32* pSrc;
+	UINT32* pDest;
+
+	pSrc = pImage->image;
+	pDest = pImage->pDestination;
+
+	if (pSrc != pDest) // if not linked to that flash address
+	{
+		if (pImage->flags & IF_UCL_2E)
+		{	// UCL compressed, algorithm 2e
+			UINT32 dst_len; // dummy
+			ucl_nrv2e_decompress_8((UINT8*)pSrc, (UINT8*)pDest, &dst_len);
+		}
+		else
+		{	// uncompressed, copy it
+			UINT32 size = pImage->size;
+			UINT32* pEnd;
+			size = (size + 3) / 4; // round up to 32bit-words
+			pEnd = pDest + size;
+
+			do
+			{
+				*pDest++ = *pSrc++;
+			}
+			while (pDest < pEnd);
+		}
+	}
+
+	pImage->pExecute();
+}
+
+
+int ReadADC(int channel)
+{
+	// after channel 3, the ports wrap and get re-used
+	volatile UINT16* pResult = (UINT16*)(ADDRAH_ADDR + 2 * (channel & 0x03)); 
+	int timeout = 266; // conversion takes 266 clock cycles
+
+	ADCSR = 0x20 | channel; // start single conversion
+	while (((ADCSR & 0x80) == 0) && (--timeout)); // 6 instructions per round
+
+	return (timeout == 0) ? -1 : *pResult>>6;
+}
+
+
+// This function is platform-dependent, 
+//	until I figure out how to distinguish at runtime.
+int ButtonPressed(void) // return 1,2,3 for F1,F2,F3, 0 if none pressed
+{
+	int value = ReadADC(CHANNEL);
+
+	if (value >= F1_LOWER && value <= F1_UPPER) // in range
+		return 1;
+	else if (value >= F2_LOWER && value <= F2_UPPER) // in range
+		return 2;
+	else if (value >= F3_LOWER && value <= F3_UPPER) // in range
+		return 3;
+	
+	return 0;
+}
+
+
+// Determine the image to be started
+tImage* GetStartImage(int nPreferred)
+{
+	tImage* pImage1;
+	tImage* pImage2 = NULL; // default to not present
+	UINT32 pos;
+	UINT32* pFlash = (UINT32*)FLASH_BASE;
+
+	// determine the first image position
+	pos = pFlash[2] + pFlash[3]; // position + size of the bootloader = after it
+	pos = (pos + 3) & ~3; // be shure it's 32 bit aligned
+
+	pImage1 = (tImage*)pos;
+
+	if (pImage1->size != 0)
+	{	// check for second image
+		pos = (UINT32)(&pImage1->image) + pImage1->size;
+		pImage2 = (tImage*)pos;
+
+		// does it make sense? (not in FF or 00 erazed space)
+		if (pImage2->pDestination == (void*)0xFFFFFFFF
+		 || pImage2->size == 0xFFFFFFFF
+		 || pImage2->pExecute == (void*)0xFFFFFFFF
+		 || pImage2->flags == 0xFFFFFFFF
+		 || pImage2->pDestination == NULL) // size, execute and flags can legally be 0		
+		{
+			pImage2 = NULL; // invalidate
+		}
+	}
+
+	if (pImage2 == NULL || nPreferred == 1)
+	{	// no second image or overridden: return the first
+		return pImage1;
+	}
+
+	return pImage2; // return second image
+}
+
+// diagnostic functions
+
+void SetLed(BOOL bOn)
+{
+	if (bOn)
+		PBDR |= 0x40;
+	else
+		PBDR &= ~0x40;
+}
+
+
+void UartInit(void)
+{
+	PBIOR &= 0xFBFF; // input: RXD1 remote pin
+	PBCR1 |= 0x00A0; // set PB3+PB2 to UART
+	PBCR1 &= 0xFFAF; // clear bits 6, 4 -> UART
+	SMR1  =  0x0000; // async format 8N1, baud generator input is CPU clock
+	SCR1  =  0x0030; // transmit+receive enable
+	PBCR1 &= 0x00FF; // set bit 12...15 as GPIO
+	SSR1  &= 0x00BF; // clear bit 6 (RDRF, receive data register full)
+}
+
+
+UINT8 UartRead(void)
+{
+	UINT8 byte;
+	while (!(SSR1 & SCI_RDRF)); // wait for char to be available
+	byte = RDR1;
+	SSR1 &= ~SCI_RDRF;
+	return byte;
+}
+
+
+void UartWrite(UINT8 byte)
+{
+	while (!(SSR1 & SCI_TDRE)); // wait for transmit buffer empty
+	TDR1 = byte;
+	SSR1 &= ~SCI_TDRE;
+}
+
+
+// include the mini monitor as a rescue feature, started with F3
+void MiniMon(void)
+{
+	UINT8 cmd;
+	UINT32 addr;
+	UINT32 size;
+	UINT32 content;
+	volatile UINT8* paddr = NULL;
+	volatile UINT8* pflash = NULL; // flash base address
+
+	UartInit();
+
+	while (1)
+	{
+		cmd = UartRead();
+		switch (cmd)
+		{
+		case BAUDRATE:
+			content = UartRead();
+			UartWrite(cmd); // acknowledge by returning the command value
+			while (!(SSR1 & SCI_TEND)); // wait for empty shift register, before changing baudrate
+			BRR1 = content;
+			break;
+
+		case ADDRESS:
+			addr = (UartRead() << 24) | (UartRead() << 16) | (UartRead() << 8) | UartRead();
+			paddr = (UINT8*)addr;
+			pflash = (UINT8*)(addr & 0xFFF80000); // round down to 512k align
+			UartWrite(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_READ:
+			content = *paddr++;
+			UartWrite(content); // the content is the ack	
+			break;
+
+		case BYTE_WRITE:
+			content = UartRead();
+			*paddr++ = content;
+			UartWrite(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_READ16:
+			size = 16;
+			while (size--)
+			{
+				content = *paddr++;
+				UartWrite(content); // the content is the ack
+			}
+			break;
+
+		case BYTE_WRITE16:
+			size = 16;
+			while (size--)
+			{
+				content = UartRead();
+				*paddr++ = content;
+			}
+			UartWrite(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_FLASH:
+			content = UartRead();
+			pflash[0x5555] = 0xAA; // set flash to command mode
+			pflash[0x2AAA] = 0x55;
+			pflash[0x5555] = 0xA0; // byte program command
+			*paddr++ = content;
+			UartWrite(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_FLASH16:
+			size = 16;
+			while (size--)
+			{
+				content = UartRead();
+				pflash[0x5555] = 0xAA; // set flash to command mode
+				pflash[0x2AAA] = 0x55;
+				pflash[0x5555] = 0xA0; // byte program command
+				*paddr++ = content;
+			}
+			UartWrite(cmd); // acknowledge by returning the command value
+			break;
+
+		case HALFWORD_READ:
+			content = *(UINT16*)paddr;
+			paddr += 2;
+			UartWrite(content >> 8); // highbyte
+			UartWrite(content & 0xFF); // lowbyte
+			break;
+		
+		case HALFWORD_WRITE:
+			content = UartRead() << 8 | UartRead();
+			*(UINT16*)paddr = content;
+			paddr += 2;
+			UartWrite(cmd); // acknowledge by returning the command value
+			break;
+		
+		case EXECUTE:
+			{
+				tpFunc pFunc = (tpFunc)paddr;
+				pFunc();
+				UartWrite(cmd); // acknowledge by returning the command value
+			}
+			break;
+
+		case VERSION:
+			UartWrite(1); // return our version number
+			break;
+
+		default:
+			{
+				SetLed(TRUE);
+				UartWrite(~cmd); // error acknowledge
+			}
+
+		} // case
+	} // while (1)
+}
diff --git a/flash/bootloader/bootloader.h b/flash/bootloader/bootloader.h
new file mode 100644
index 0000000..eee61c4
--- /dev/null
+++ b/flash/bootloader/bootloader.h
@@ -0,0 +1,111 @@
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#define TRUE 1
+#define FALSE 0
+
+// scalar types
+typedef unsigned char  UINT8;
+typedef unsigned short UINT16;
+typedef unsigned long  UINT32;
+typedef int BOOL;
+
+typedef void(*tpFunc)(void); // type for execute
+typedef int(*tpMain)(void); // type for start vector to main()
+
+
+// structure of an image in the flash
+typedef struct 
+{
+	UINT32* pDestination; // address to copy it to
+	UINT32 size;          // how many bytes of payload (to the next header)
+	tpFunc pExecute;      // entry point
+	UINT32 flags;         // uncompressed or compressed
+	// end of header, now comes the payload
+	UINT32 image[];       // the binary image starts here
+	// after the payload, the next header may follow, all 0xFF if none
+} tImage;
+
+// flags valid for image header
+#define IF_NONE   0x00000000
+#define IF_UCL_2E 0x00000001 // image is compressed with UCL, algorithm 2e
+
+
+// resolve platform dependency of F1 button check
+#if defined PLATFORM_PLAYER
+#define CHANNEL 1
+#define F1_LOWER 0  // this is the "Menu" key
+#define F1_UPPER 384
+#define F2_LOWER 1024 // not present
+#define F2_UPPER 1024
+#define F3_LOWER 1024
+#define F3_UPPER 1024
+#elif defined PLATFORM_RECORDER
+#define CHANNEL 4
+#define F1_LOWER 250
+#define F1_UPPER 499
+#define F2_LOWER 500
+#define F2_UPPER 699
+#define F3_LOWER 900
+#define F3_UPPER 1023
+#elif defined PLATFORM_FM
+#define CHANNEL 4
+#define F1_LOWER 150
+#define F1_UPPER 384
+#define F2_LOWER 385
+#define F2_UPPER 544
+#define F3_LOWER 700
+#define F3_UPPER 1023
+#else
+#error ("No platform given!")
+#endif
+
+#define FLASH_BASE 0x02000000 // start of the flash memory
+#define FW_VERSION *(unsigned short*)(FLASH_BASE + 0xFE) // firmware version
+
+
+// prototypes
+void _main(void) __attribute__ ((section (".startup")));
+int main(void);
+void PlatformInit(void);
+void DramInit(void);
+int ucl_nrv2e_decompress_8(const UINT8 *src, UINT8 *dst, UINT32* dst_len);
+void DecompressStart(tImage* pImage);
+int ReadADC(int channel);
+int ButtonPressed(void);
+tImage* GetStartImage(int nPreferred);
+// test functions
+void SetLed(BOOL bOn);
+void UartInit(void);
+UINT8 UartRead(void);
+void UartWrite(UINT8 byte);
+void MiniMon(void);
+
+
+// minimon commands
+#define BAUDRATE       0x00 // followed by BRR value; response: command byte
+#define ADDRESS        0x01 // followed by 4 bytes address; response: command byte
+#define BYTE_READ      0x02 // response: 1 byte content
+#define BYTE_WRITE     0x03 // followed by 1 byte content; response: command byte
+#define BYTE_READ16    0x04 // response: 16 bytes content
+#define BYTE_WRITE16   0x05 // followed by 16 bytes; response: command byte
+#define BYTE_FLASH     0x06 // followed by 1 byte content; response: command byte
+#define BYTE_FLASH16   0x07 // followed by 16 bytes; response: command byte
+#define HALFWORD_READ  0x08 // response: 2 byte content
+#define HALFWORD_WRITE 0x09 // followed by 2 byte content; response: command byte
+#define EXECUTE        0x0A // response: command byte if call returns
+#define VERSION        0x0B // response: version
+
+
+// linker symbols
+extern UINT32 begin_text[];
+extern UINT32 end_text[];
+extern UINT32 begin_data[];
+extern UINT32 end_data[];
+extern UINT32 begin_bss[];
+extern UINT32 end_bss[];
+extern UINT32 begin_stack[];
+extern UINT32 end_stack[];
+extern UINT32 begin_iramcopy[];
+extern UINT32 total_size[];
diff --git a/flash/bootloader/bootloader.lds b/flash/bootloader/bootloader.lds
new file mode 100644
index 0000000..143d83b
--- /dev/null
+++ b/flash/bootloader/bootloader.lds
@@ -0,0 +1,34 @@
+OUTPUT_FORMAT(elf32-sh)
+INPUT(bootloader.o)
+
+MEMORY
+{
+	/* the boot ROM uses IRAM at 400-430, stay away and start at 500 */
+	IRAM : ORIGIN = 0x0FFFF500, LENGTH = 0xA00
+	/* and leave some room for stack at the end */
+}
+
+SECTIONS
+{
+	.startvector :
+	{
+		*(.startvector)
+		. = ALIGN(0x4);
+	} > IRAM
+
+	.text :
+	{	 
+		*(.text)	
+		. = ALIGN(0x4);
+	} > IRAM
+	
+	.data :
+	{
+		*(.data)
+	} > IRAM
+
+	.bss :
+	{
+	   *(.bss)
+	} > IRAM
+}
diff --git a/flash/bootloader/no_rom.lds b/flash/bootloader/no_rom.lds
new file mode 100644
index 0000000..e65e7fd
--- /dev/null
+++ b/flash/bootloader/no_rom.lds
@@ -0,0 +1,62 @@
+/* This is for the variant without boot ROM,
+   where the flash ROM is mirrored to address zero */
+
+OUTPUT_FORMAT(elf32-sh)
+INPUT(bootloader.o)
+
+MEMORY
+{
+	IRAM : ORIGIN = 0x0FFFF000, LENGTH = 0x1000
+	FLASH : ORIGIN = 0x00000000, LENGTH = 0x40000
+}
+
+SECTIONS
+{
+	.vectors :
+	{
+		*(.vectors)
+		. = ALIGN(0x200);
+	} > FLASH
+
+	.startup :
+	{
+		*(.startup)
+		. = ALIGN(0x4);
+		_begin_iramcopy = .;
+	} > FLASH
+
+	.text : AT ( _begin_iramcopy )
+	{	 
+		_begin_text = .;
+		*(.text)	
+		. = ALIGN(0x4);
+		_end_text = .;
+	} > IRAM
+	
+	.data : AT ( _end_text )
+	{
+		_begin_data = .;
+		*(.data)
+		. = ALIGN(0x4);
+		_end_data = .;
+	} > IRAM
+
+	.bss : AT ( _end_data )
+	{
+		_begin_bss = .;
+		*(.bss)
+		. = ALIGN(0x4);
+		_end_bss = .;
+	} > IRAM
+
+	.stack :
+	{
+		_begin_stack = .;
+		*(.stack)
+		. = ALIGN(0x1000);
+		_end_stack = .;
+	} > IRAM
+
+	/* size of the program (without vectors) */
+	_total_size = SIZEOF(.startup) + SIZEOF(.text) + SIZEOF(.data);
+}
diff --git a/flash/extract/README b/flash/extract/README
new file mode 100644
index 0000000..b66443a
--- /dev/null
+++ b/flash/extract/README
@@ -0,0 +1,5 @@
+(c) 2003 by Jörg Hohensohn
+
+This tool extracts the firmware image out of an original Archos ROM dump,
+like created with the Rockbox debug->dump feature.
+The extracted image can then be used to compose a dual-boot firmware.
diff --git a/flash/extract/extract.c b/flash/extract/extract.c
new file mode 100644
index 0000000..31e223a
--- /dev/null
+++ b/flash/extract/extract.c
@@ -0,0 +1,140 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2003 by Jörg Hohensohn 
+ * 
+ * Tool to extract the scrambled image out of an Archos flash ROM dump
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+
+#define UINT8 unsigned char
+#define UINT16 unsigned short
+#define UINT32 unsigned long
+
+#define IMAGE_HEADER 0x6000 // a 32 byte header in front of the software image
+#define IMAGE_START  0x6020	// software image position in Flash
+
+
+// place a 32 bit value into memory, big endian
+void Write32(UINT8* pByte, UINT32 value)
+{
+	pByte[0] = (UINT8)(value >> 24);	
+	pByte[1] = (UINT8)(value >> 16);	
+	pByte[2] = (UINT8)(value >> 8);	
+	pByte[3] = (UINT8)(value);	
+}
+
+
+// read a 32 bit value from memory, big endian
+UINT32 Read32(UINT8* pByte)
+{
+	UINT32 value = 0;
+
+	value |= (UINT32)pByte[0] << 24;
+	value |= (UINT32)pByte[1] << 16;
+	value |= (UINT32)pByte[2] << 8;
+	value |= (UINT32)pByte[3];
+
+	return value;
+}
+
+
+// entry point
+int main(int argc, char* argv[])
+{
+	FILE* pInFile;
+	FILE* pOutFile;
+	UINT8 aHeader[6];
+	UINT8 aImage[256*1024];
+	UINT32 i;
+	UINT32 uiSize, uiStart;
+	UINT16 usChecksum = 0;
+	
+	if (argc < 2)
+	{
+		printf("Extract the software image out of an original Archos Flash ROM dump.\n");
+		printf("Result is a scrambled file, use the descramble tool to get the binary,\n");
+		printf(" always without the -fm option, even if processing an FM software.\n\n");
+		printf("Usage: extract <flash dump file> <output file>\n");
+		printf("Example: extract internal_rom_2000000-203FFFF.bin archos.ajz\n");
+		exit(0);
+	}
+	
+	pInFile = fopen(argv[1], "rb");
+	if (pInFile == NULL)
+	{
+		printf("Error opening input file %s\n", argv[1]);
+		exit(1);
+	}
+
+	if (fread(aImage, 1, sizeof(aImage), pInFile) != sizeof(aImage))
+	{
+		printf("Error reading input file %s, must be 256kB in size.\n", argv[1]);
+		fclose(pInFile);
+		exit(2);
+	}
+	fclose(pInFile);
+
+	// find out about the type
+	uiStart = Read32(aImage + 8);
+	uiSize = Read32(aImage + 12); // booted ROM image
+	if (uiStart == 0x02000100 && uiSize > 20000)
+	{	// Player has no loader, starts directly with the image
+		uiStart = 0x0100;
+	}
+	else
+	{	// Recorder / FM / V2 Recorder
+		uiStart = IMAGE_START;
+		uiSize = Read32(aImage + IMAGE_HEADER + 4); // size record of header
+	}
+
+	// sanity check
+	if (uiSize > sizeof(aImage) - uiStart || uiSize < 40000)
+	{	
+		printf("Error: Impossible image size &d bytes.\n", uiSize);
+		exit(3);
+	}
+
+	// generate checksum
+	for (i=0; i<uiSize; i++)
+		usChecksum += aImage[uiStart + i];
+
+	// make header
+	Write32(aHeader + 2, usChecksum); // checksum in 5th and 6th byte
+	Write32(aHeader, uiSize); // size in first 4 bytes
+
+	pOutFile = fopen(argv[2], "wb");
+	if (pOutFile == NULL)
+	{
+		printf("Error opening output file %s\n", argv[2]);
+		exit(4);
+	}
+
+	if (fwrite(aHeader, 1, sizeof(aHeader), pOutFile) != sizeof(aHeader)
+	 || fwrite(aImage + uiStart, 1, uiSize, pOutFile) != uiSize)
+	{
+		printf("Write error\n");
+		fclose(pOutFile);
+		exit(5);
+	}
+
+	fclose(pOutFile);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/flash/extract/extract.dsp b/flash/extract/extract.dsp
new file mode 100644
index 0000000..e10281a
--- /dev/null
+++ b/flash/extract/extract.dsp
@@ -0,0 +1,100 @@
+# Microsoft Developer Studio Project File - Name="extract" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=extract - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "extract.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "extract.mak" CFG="extract - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "extract - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "extract - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "extract - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x407 /d "NDEBUG"
+# ADD RSC /l 0x407 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "extract - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x407 /d "_DEBUG"
+# ADD RSC /l 0x407 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "extract - Win32 Release"
+# Name "extract - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\extract.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
diff --git a/flash/make_firmware/README b/flash/make_firmware/README
new file mode 100644
index 0000000..7110610
--- /dev/null
+++ b/flash/make_firmware/README
@@ -0,0 +1,14 @@
+(c) 2003 by Jörg Hohensohn
+
+This tool composes a firmware file, out of:
+1. Template for the first Flash page
+2. Bootloader
+3. Archos image
+4. Rockbox image
+
+Use with extreme caution, the components have to match!
+The aspects are:
+- Model (Player, Recorder, FM, V2)
+- boot type (standard boot ROM or ROMless)
+
+Such a firmware file can then be programmed with "firmware_flash.rock".
diff --git a/flash/make_firmware/make_firmware.c b/flash/make_firmware/make_firmware.c
new file mode 100644
index 0000000..220db4e
--- /dev/null
+++ b/flash/make_firmware/make_firmware.c
@@ -0,0 +1,338 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2003 by Jörg Hohensohn 
+ * 
+ * Autoring tool for the firmware image to be programmed into Flash ROM
+ * It composes the flash content with header, bootloader and image(s)
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <string.h>
+
+#define UINT8 unsigned char
+#define UINT16 unsigned short
+#define UINT32 unsigned long
+#define BOOL int
+#define TRUE 1
+#define FALSE 0
+
+// size of one flash sector, the granularity with which it can be erased
+#define SECTORSIZE 4096 
+
+#define BOOTLOAD_DEST 0x0FFFF500 // for the "normal" one
+#define BOOTLOAD_SCR 0x02000100
+#define ROCKBOX_DEST 0x09000000
+#define ROCKBOX_EXEC 0x09000200
+
+
+// place a 32 bit value into memory, big endian
+void Write32(UINT8* pByte, UINT32 value)
+{
+	pByte[0] = (UINT8)(value >> 24);	
+	pByte[1] = (UINT8)(value >> 16);	
+	pByte[2] = (UINT8)(value >> 8);
+	pByte[3] = (UINT8)(value);	
+}
+
+
+// read a 32 bit value from memory, big endian
+UINT32 Read32(UINT8* pByte)
+{
+	UINT32 value = 0;
+
+	value |= (UINT32)pByte[0] << 24;
+	value |= (UINT32)pByte[1] << 16;
+	value |= (UINT32)pByte[2] << 8;
+	value |= (UINT32)pByte[3];
+
+	return value;
+}
+
+
+UINT32 CalcCRC32 (const UINT8* buf, UINT32 len) 
+{ 
+	static const UINT32 crc_table[256] = 
+	{	// CRC32 lookup table for polynomial 0x04C11DB7
+		0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B, 
+		0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61, 
+		0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD, 0x4C11DB70, 0x48D0C6C7, 
+		0x4593E01E, 0x4152FDA9, 0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75, 
+		0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3, 
+		0x709F7B7A, 0x745E66CD, 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039, 
+		0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58, 0xBAEA46EF, 
+		0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D, 
+		0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49, 0xC7361B4C, 0xC3F706FB, 
+		0xCEB42022, 0xCA753D95, 0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1, 
+		0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, 0x34867077, 0x30476DC0, 
+		0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072, 
+		0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16, 0x018AEB13, 0x054BF6A4, 
+		0x0808D07D, 0x0CC9CDCA, 0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE, 
+		0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08, 
+		0x571D7DD1, 0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA, 
+		0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B, 0xBB60ADFC, 
+		0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6, 
+		0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A, 0xE0B41DE7, 0xE4750050, 
+		0xE9362689, 0xEDF73B3E, 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2, 
+		0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34, 
+		0xDC3ABDED, 0xD8FBA05A, 0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637, 
+		0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB, 0x4F040D56, 0x4BC510E1, 
+		0x46863638, 0x42472B8F, 0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53, 
+		0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5, 
+		0x3F9B762C, 0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF, 
+		0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, 0xF12F560E, 0xF5EE4BB9, 
+		0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B, 
+		0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD, 
+		0xCDA1F604, 0xC960EBB3, 0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7, 
+		0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71, 
+		0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3, 
+		0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640, 0x4E8EE645, 0x4A4FFBF2, 
+		0x470CDD2B, 0x43CDC09C, 0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8, 
+		0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24, 0x119B4BE9, 0x155A565E, 
+		0x18197087, 0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC, 
+		0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D, 0x2056CD3A, 
+		0x2D15EBE3, 0x29D4F654, 0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0, 
+		0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C, 0xE3A1CBC1, 0xE760D676, 
+		0xEA23F0AF, 0xEEE2ED18, 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4, 
+		0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662, 
+		0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668, 
+		0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4 
+	};
+	UINT32 i;
+	UINT32 crc = 0xffffffff;
+
+	for (i = 0; i < len; i++)
+		crc = (crc << 8) ^ crc_table[((crc >> 24) ^ *buf++) & 0xFF];
+
+	return crc; 
+} 
+
+
+UINT32 PlaceImage(char* filename, UINT32 pos, UINT8* pFirmware, UINT32 limit)
+{
+	UINT32 size, read;
+	FILE* pFile;
+	UINT32 align;
+	UINT32 flags;
+
+	// magic file header for compressed files
+	static const UINT8 magic[8] = { 0x00,0xe9,0x55,0x43,0x4c,0xff,0x01,0x1a };
+	UINT8 ucl_header[26];
+
+	pFile = fopen(filename, "rb"); // open the current image
+	if (pFile == NULL)
+	{
+		printf("Image file %s not found!\n", filename);
+		exit(5);
+	}
+
+	fseek(pFile, 0, SEEK_END);
+	size = ftell(pFile);
+	fseek(pFile, 0, SEEK_SET);
+
+	// determine if compressed
+	flags = 0x00000000; // default: flags for uncompressed
+	fread(ucl_header, 1, sizeof(ucl_header), pFile);
+	if (memcmp(magic, ucl_header, sizeof(magic)) == 0)
+	{
+		if (ucl_header[12] != 0x2E) // check algorithm
+		{
+			printf("UCL compressed files must use algorithm 2e, not %d\n", ucl_header[12]);
+			printf("Generate with: uclpack --best --2e rockbox.bin %s\n", filename);
+			exit(6);
+		}
+		
+		size = Read32(ucl_header + 22); // compressed size
+		if (Read32(ucl_header + 18) > size) // compare with uncompressed size
+		{	// normal case
+			flags = 0x00000001; // flags for UCL compressed
+		}
+	}
+	else
+	{
+		fseek(pFile, 0, SEEK_SET); // go back
+	}
+
+	if (pos + 16 + size > limit) // enough space for all that?
+	{
+		printf("Exceeding maximum image size %d\n", limit);
+		exit(7);
+	}
+	
+	// write header
+	align = (pos + 16 + size + SECTORSIZE-1) & ~(SECTORSIZE-1); // round up to next flash sector
+	Write32(pFirmware + pos, ROCKBOX_DEST); // load address
+	Write32(pFirmware + pos + 4, align - (pos + 16)); // image size
+	Write32(pFirmware + pos + 8, ROCKBOX_EXEC); // execution address
+	Write32(pFirmware + pos + 12, flags); // compressed or not
+	pos += 16;
+
+	// load image
+	read = fread(pFirmware + pos, 1, size, pFile);
+	if (read != size)
+	{
+		printf("Read error, expecting %d bytes, got only %d\n", size, read);
+		exit(8);
+	}
+	fclose (pFile);
+
+	pos += size;
+
+	return pos;
+}
+
+
+int main(int argc, char* argv[])
+{
+	static UINT8 aFirmware[512*1024]; // maximum with exchanged chip
+	FILE* pFile;
+	UINT32 size; // size of loaded item
+	UINT32 pos; // current position in firmware
+	UINT32 crc32; // checksum of "payload"
+	BOOL hasBootRom; // flag if regular boot ROM or directly starts from flash
+	UINT32 template_F8, template_FC; // my platform ID, mask and version
+
+	int i;
+	
+	if (argc <= 4)
+	{
+		printf("Usage:\n");
+		printf("make_firmware <output> <template.bin> <bootloader.ajz> <image1.ucl> {image2.ucl}\n");
+		printf("<template.bin> is the original firmware from your box\n");
+		printf("<bootloader.ajz> is the scrambled bootloader\n");
+		printf("<image1.ucl> is the first image, compressed (recommended) or uncompressed\n");
+		printf("<image1.ucl> is the second image, compressed (recommended) or uncompressed\n");
+		printf("More images may follow, but keep the flash size in mind!\n");
+		printf("Compression must be UCL, algorithm 2e.\n");
+		printf("Generated with: uclpack --best --2e rockbox.bin imageN.ucl\n");
+		exit(0);
+	}
+	
+	memset(aFirmware, 0xFF, sizeof(aFirmware));
+	
+	/******* process template *******/
+	
+	pFile = fopen(argv[2], "rb"); // open the template
+	if (pFile == NULL)
+	{
+		printf("Template file %s not found!\n", argv[2]);
+		exit(1);
+	}
+	size = fread(aFirmware, 1, 256, pFile); // need only the header
+	fclose(pFile);
+	if (size < 256) // need at least the firmware header
+	{
+		printf("Template file %s too small, need at least the header!\n", argv[2]);
+		exit(2);
+	}
+
+	if (strncmp(aFirmware, "ARCH", 4) == 0)
+	{
+		hasBootRom = TRUE;
+		pos = 256; // place bootloader after this "boot block"
+	}
+	else if (Read32(aFirmware) == 0x0200)
+	{
+		hasBootRom = FALSE;
+		pos = 0; // directly start with the bootloader
+		template_F8 = Read32(aFirmware + 0xF8); // my platform ID and future info
+		template_FC = Read32(aFirmware + 0xFC); // use mask+version from template
+	}
+	else
+	{
+		printf("Template file %s invalid!\n", argv[2]);
+		exit(3);
+	}
+	
+	/******* process bootloader *******/
+
+	pFile = fopen(argv[3], "rb"); // open the bootloader
+	if (pFile == NULL)
+	{
+		printf("Bootloader file %s not found!\n", argv[3]);
+		exit(4);
+	}
+	if (hasBootRom && fseek(pFile, 6, SEEK_SET)) // skip the ajz header
+	{
+		printf("Bootloader file %s too short!\n", argv[3]);
+		exit(5);
+	}
+
+	// place bootloader after header
+	size = fread(aFirmware + pos, 1, sizeof(aFirmware) - pos, pFile);
+	fclose(pFile);
+
+	if (hasBootRom)
+	{
+		Write32(aFirmware + 4, BOOTLOAD_DEST); // boot code destination address
+		
+		for (i=0x08; i<=0x28; i+=8)
+		{
+			Write32(aFirmware + i, BOOTLOAD_SCR); // boot code source address
+			Write32(aFirmware + i + 4, size); // boot code size
+		}
+	}
+	else
+	{
+		Write32(aFirmware + 0xF8, template_F8); // values from template
+		Write32(aFirmware + 0xFC, template_FC); // mask and version
+	}
+
+	size = (size + 3) & ~3; // make shure it's 32 bit aligned
+	pos += size; // prepare position for first image
+
+	/******* process images *******/
+	for (i = 4; i < argc; i++)
+	{
+		pos = PlaceImage(argv[i], pos, aFirmware, sizeof(aFirmware));
+
+		if (i < argc-1)
+		{	// not the last: round up to next flash sector
+			pos = (pos + SECTORSIZE-1) & ~(SECTORSIZE-1);
+		}
+	}
+	
+
+	/******* append CRC32 checksum *******/
+	crc32 = CalcCRC32(aFirmware, pos);
+	Write32(aFirmware + pos, crc32);
+	pos += sizeof(crc32); // 4 bytes
+	
+	
+	/******* save result to output file *******/
+
+	pFile = fopen(argv[1], "wb"); // open the output file
+	if (pFile == NULL)
+	{
+		printf("Output file %s cannot be created!\n", argv[1]);
+		exit(9);
+	}
+	size = fwrite(aFirmware, 1, pos, pFile);
+	fclose(pFile);
+	
+	if (size != pos)
+	{
+		printf("Error writing %d bytes to output file %s!\n", pos, argv[1]);
+		exit(10);
+	}
+
+	printf("Firmware file generated with %d bytes.\n", pos);
+
+	return 0;
+}
diff --git a/flash/make_firmware/make_firmware.dsp b/flash/make_firmware/make_firmware.dsp
new file mode 100644
index 0000000..54a6f53
--- /dev/null
+++ b/flash/make_firmware/make_firmware.dsp
@@ -0,0 +1,96 @@
+# Microsoft Developer Studio Project File - Name="make_firmware" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=make_firmware - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "make_firmware.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "make_firmware.mak" CFG="make_firmware - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "make_firmware - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "make_firmware - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "make_firmware - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX"stdafx.h" /FD /c
+# ADD BASE RSC /l 0x407 /d "NDEBUG"
+# ADD RSC /l 0x407 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "make_firmware - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX"stdafx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x407 /d "_DEBUG"
+# ADD RSC /l 0x407 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "make_firmware - Win32 Release"
+# Name "make_firmware - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\make_firmware.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# End Target
+# End Project
diff --git a/flash/minimon/Makefile b/flash/minimon/Makefile
new file mode 100644
index 0000000..57ae13e
--- /dev/null
+++ b/flash/minimon/Makefile
@@ -0,0 +1,53 @@
+#             __________               __   ___.
+#   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+#   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+#   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+#   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+#                     \/            \/     \/    \/            \/
+# $Id$
+#
+
+CC    = sh-elf-gcc 
+LD    = sh-elf-ld
+AR    = sh-elf-ar
+AS    = sh-elf-as
+OC    = sh-elf-objcopy
+
+FIRMWARE := ../../firmware
+TOOLSDIR=../../tools
+
+TARGET = minimon
+LDS := $(TARGET).lds
+
+INCLUDES= -I$(FIRMWARE)/export -I. -I$(OBJDIR)
+OBJDIR := .
+
+CFLAGS = -fpic -O -W -Wall -m1 -nostdlib -ffreestanding -Wstrict-prototypes -fomit-frame-pointer -fschedule-insns $(INCLUDES) $(DEFINES)
+AFLAGS += -small -relax
+
+
+ifdef DEBUG
+    DEFINES := -DDEBUG
+    CFLAGS += -g
+endif
+
+SRC := $(wildcard *.c)
+
+OBJS := $(SRC:%.c=$(OBJDIR)/%.o)
+
+LINKFILE = $(OBJDIR)/$(TARGET).lds
+
+
+$(OBJDIR)/$(TARGET).bin : $(OBJDIR)/$(TARGET).elf
+	$(OC) -O binary $(OBJDIR)/$(TARGET).elf $(OBJDIR)/$(TARGET).bin
+	$(TOOLSDIR)/sh2d $(OBJDIR)/$(TARGET).bin -o 0900000 > $(OBJDIR)/$(TARGET).asm
+
+$(OBJDIR)/$(TARGET).elf : $(OBJS) 
+	$(CC) -Os -nostdlib -o $(OBJDIR)/$(TARGET).elf -L$(OBJDIR) -T$(LINKFILE) -Wl,-Map,$(OBJDIR)/$(TARGET).map
+
+
+clean:
+	-rm -f $(OBJS) $(OBJDIR)/$(TARGET).asm \
+	$(OBJDIR)/$(TARGET).bin \
+	$(OBJDIR)/$(TARGET).elf \
+	$(OBJDIR)/$(TARGET).map
diff --git a/flash/minimon/README b/flash/minimon/README
new file mode 100644
index 0000000..b80edd9
--- /dev/null
+++ b/flash/minimon/README
@@ -0,0 +1,6 @@
+(c) 2003 by Jörg Hohensohn
+
+MiniMon is the tiny but powerful-enough piece of code that can be loaded
+with the UART boot mod. 
+It allows to read and write memory, flash program, execute code.
+This is suitable to reflash the box, load Rockbox or the gdb stub, etc.
diff --git a/flash/minimon/minimon.c b/flash/minimon/minimon.c
new file mode 100644
index 0000000..e7981f2
--- /dev/null
+++ b/flash/minimon/minimon.c
@@ -0,0 +1,156 @@
+// minimalistic monitor
+// to be loaded with the UART boot feature
+// capable of reading and writing bytes, commanded by UART
+
+#include "sh7034.h"
+#include "minimon.h"
+
+// scalar types
+typedef unsigned char  UINT8;
+typedef unsigned short UINT16;
+typedef unsigned long  UINT32;
+
+typedef void(*tpFunc)(void); // type for exec
+typedef int(*tpMain)(void); // type for start vector to main()
+
+
+// prototypes
+int main(void);
+
+// our binary has to start with a vector to the entry point
+tpMain start_vector[] __attribute__ ((section (".startvector"))) = {main};
+
+
+UINT8 uart_read(void)
+{
+	UINT8 byte;
+	while (!(SSR1 & SCI_RDRF)); // wait for char to be available
+	byte = RDR1;
+	SSR1 &= ~SCI_RDRF;
+	return byte;
+}
+
+
+void uart_write(UINT8 byte)
+{
+	while (!(SSR1 & SCI_TDRE)); // wait for transmit buffer empty
+	TDR1 = byte;
+	SSR1 &= ~SCI_TDRE;
+}
+
+
+int main(void)
+{
+	UINT8 cmd;
+	UINT32 addr;
+	UINT32 size;
+	UINT32 content;
+	volatile UINT8* paddr = 0;
+	volatile UINT8* pflash; // flash base address
+
+	while (1)
+	{
+		cmd = uart_read();
+		switch (cmd)
+		{
+		case BAUDRATE:
+			content = uart_read();
+			uart_write(cmd); // acknowledge by returning the command value
+			while (!(SSR1 & SCI_TEND)); // wait for empty shift register, before changing baudrate
+			BRR1 = content;
+			break;
+
+		case ADDRESS:
+			addr = (uart_read() << 24) | (uart_read() << 16) | (uart_read() << 8) | uart_read();
+			paddr = (UINT8*)addr;
+			pflash = (UINT8*)(addr & 0xFFF80000); // round down to 512k align
+			uart_write(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_READ:
+			content = *paddr++;
+			uart_write(content); // the content is the ack	
+			break;
+
+		case BYTE_WRITE:
+			content = uart_read();
+			*paddr++ = content;						
+			uart_write(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_READ16:
+			size = 16;
+			while (size--)
+			{
+				content = *paddr++;
+				uart_write(content); // the content is the ack		
+			}
+			break;
+
+		case BYTE_WRITE16:
+			size = 16;
+			while (size--)
+			{
+				content = uart_read();
+				*paddr++ = content;						
+			}
+			uart_write(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_FLASH:
+			content = uart_read();
+			pflash[0x5555] = 0xAA; // set flash to command mode
+			pflash[0x2AAA] = 0x55;
+			pflash[0x5555] = 0xA0; // byte program command
+			*paddr++ = content;						
+			uart_write(cmd); // acknowledge by returning the command value
+			break;
+
+		case BYTE_FLASH16:
+			size = 16;
+			while (size--)
+			{
+				content = uart_read();
+				pflash[0x5555] = 0xAA; // set flash to command mode
+				pflash[0x2AAA] = 0x55;
+				pflash[0x5555] = 0xA0; // byte program command
+				*paddr++ = content;						
+			}
+			uart_write(cmd); // acknowledge by returning the command value
+			break;
+
+		case HALFWORD_READ:
+			content = *(UINT16*)paddr;
+			paddr += 2;
+			uart_write(content >> 8); // highbyte
+			uart_write(content & 0xFF); // lowbyte
+			break;
+		
+		case HALFWORD_WRITE:
+			content = uart_read() << 8 | uart_read();
+			*(UINT16*)paddr = content;
+			paddr += 2;
+			uart_write(cmd); // acknowledge by returning the command value
+			break;
+		
+		case EXECUTE:
+			{
+				tpFunc pFunc = (tpFunc)paddr;
+				pFunc();
+				uart_write(cmd); // acknowledge by returning the command value
+			}
+			break;
+
+
+		default:
+			{
+				volatile UINT16* pPortB = (UINT16*)0x05FFFFC2;
+				*pPortB |= 1 << 6; // bit 6 is red LED on
+				uart_write(~cmd); // error acknowledge
+			}
+
+		} // case
+	}
+
+	return 0;
+}
diff --git a/flash/minimon/minimon.h b/flash/minimon/minimon.h
new file mode 100644
index 0000000..b6e9805
--- /dev/null
+++ b/flash/minimon/minimon.h
@@ -0,0 +1,24 @@
+#ifndef _MINIMON_H
+#define _MINIMON_H
+
+
+// Commands
+// all multibyte values (address, halfwords) are passed as big endian 
+//  (most significant of the bytes first)
+
+// set the address (all read/write commands will auto-increment it)
+#define BAUDRATE       0x00 // followed by BRR value; response: command byte
+#define ADDRESS        0x01 // followed by 4 bytes address; response: command byte
+#define BYTE_READ      0x02 // response: 1 byte content
+#define BYTE_WRITE     0x03 // followed by 1 byte content; response: command byte
+#define BYTE_READ16    0x04 // response: 16 bytes content
+#define BYTE_WRITE16   0x05 // followed by 16 bytes; response: command byte
+#define BYTE_FLASH     0x06 // followed by 1 byte content; response: command byte
+#define BYTE_FLASH16   0x07 // followed by 16 bytes; response: command byte
+#define HALFWORD_READ  0x08 // response: 2 byte content
+#define HALFWORD_WRITE 0x09 // followed by 2 byte content; response: command byte
+#define EXECUTE        0x0A // response: command byte if call returns
+#define VERSION        0x0B // response: version
+
+
+#endif // _MINIMON_H
diff --git a/flash/minimon/minimon.lds b/flash/minimon/minimon.lds
new file mode 100644
index 0000000..dbdbdc3
--- /dev/null
+++ b/flash/minimon/minimon.lds
@@ -0,0 +1,60 @@
+OUTPUT_FORMAT(elf32-sh)
+INPUT(minimon.o)
+
+MEMORY
+{
+	DRAM : ORIGIN = 0x09000000, LENGTH = 0x200000
+}
+
+SECTIONS
+{
+	.startvector :
+	{
+		*(.startvector)    
+		. = ALIGN(0x4);
+	} > DRAM
+
+	.got :
+	{
+	   *(.got)
+	} > DRAM
+
+	.got.plt :
+	{
+	   *(.got.plt)
+	} > DRAM
+
+	.rela.got :
+	{
+	   *(.rela.got)
+	} > DRAM
+
+	.text :    
+	{	 
+		. = ALIGN(0x200);
+		*(.entry)
+		*(.text)	
+		. = ALIGN(0x4);
+	} > DRAM
+	
+	.data :
+	{
+		*(.data)
+	} > DRAM
+
+	.rodata :
+	{
+		*(.rodata)
+		. = ALIGN(0x4);
+	} > DRAM
+
+	.bss :
+	{
+	   *(.bss)
+	} > DRAM
+
+	.stack :
+	{
+	   *(.stack)
+	} > DRAM
+}
diff --git a/flash/uart_boot/README b/flash/uart_boot/README
new file mode 100644
index 0000000..edfa20c
--- /dev/null
+++ b/flash/uart_boot/README
@@ -0,0 +1,8 @@
+(c) 2003 by Jörg Hohensohn
+
+This is the client side for MiniMon, a command line program that communicates with it.
+It can be used to reflash a box from ground up, load a program like gdb stub or Rockbox, 
+and other diagnostics.
+
+Current implementation is for Windows, but with a different UART implementation
+it should work for other platforms (Linux) as well.
diff --git a/flash/uart_boot/client.c b/flash/uart_boot/client.c
new file mode 100644
index 0000000..a98edc6
--- /dev/null
+++ b/flash/uart_boot/client.c
@@ -0,0 +1,738 @@
+// client.cpp : functions for monitor download and communication.
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "scalar_types.h" // (U)INT8/16/32
+#include "Uart.h" // platform abstraction for UART
+#include "minimon.h" // protocol of my little monitor
+
+// do the baudrate configuration for the Player
+int ConfigFirstlevelPlayer (tUartHandle serial_handle)
+{
+	UINT32 result_nbr;
+
+	if(!UartConfig(serial_handle, 4800, eMARKPARITY, eTWOSTOPBITS, 8))
+	{
+		UINT32 dwErr = GET_LAST_ERR();
+		printf("Error %d setting up COM params for baudrate byte\n", dwErr);
+		exit(1);
+	}
+
+	// this will read as 0x19 when viewed with 2300 baud like the player does
+	result_nbr = UartWrite(serial_handle, (UINT8*)"\x86\xC0", 2);
+	if (result_nbr != 2)
+	{
+		UINT32 dwErr = GET_LAST_ERR();
+		printf("Error %d setting up COM params for baudrate byte\n", dwErr);
+	}
+
+	SLEEP(100); // wait for the chars to be sent, is there a better way?
+
+	// the read 0x19 means 14423 baud with 12 MHz
+	if(!UartConfig(serial_handle, 14400, eNOPARITY, eONESTOPBIT, 8))
+	{
+		printf("Error setting up COM params for 1st level loader\n");
+		exit(1);
+	}
+
+	return 0;
+}
+
+
+// do the baudrate configuration for the Recoder/FM
+int ConfigFirstlevelRecorder (tUartHandle serial_handle)
+{
+	UINT32 result_nbr;
+
+	if(!UartConfig(serial_handle, 4800, eNOPARITY, eTWOSTOPBITS, 8))
+	{
+		UINT32 dwErr = GET_LAST_ERR();
+		printf("Error %d setting up COM params for baudrate byte\n", dwErr);
+		exit(1);
+	}
+
+	// this will read as 0x08 when viewed with 2120 baud like the recorder does
+	result_nbr = UartWrite(serial_handle, (UINT8*)"\x00\x00", 2);
+	if(result_nbr != 2)
+	{
+		printf("Error transmitting baudrate byte\n");
+		exit(1);
+	}
+
+	SLEEP(100); // wait for the chars to be sent, is there a better way?
+
+	// the read 0x08 means 38400 baud with 11.0592 MHz
+	if(!UartConfig(serial_handle, 38400, eNOPARITY, eONESTOPBIT, 8))
+	{
+		UINT32 dwErr = GET_LAST_ERR();
+		printf("Error %d setting up COM params for 1st level loader\n", dwErr);
+		exit(1);
+	}
+
+	return 0;
+}
+
+
+// transfer a byte for the monitor download, with or without acknowledge
+int DownloadByte(tUartHandle serial_handle, unsigned char byte, bool bAck)
+{
+	unsigned char received;
+	bool bRecorder = true; // false for player
+
+	while (1)
+	{
+		UartWrite(serial_handle, &byte, 1);
+		if (bAck)
+		{
+			UartRead(serial_handle, &received, 1);
+			if (received == byte)
+			{
+				UartWrite(serial_handle, (UINT8*)"\x01", 1); // ack success
+				break; // exit the loop
+			}
+			else
+			{
+				printf("Error transmitting monitor byte 0x%02X, got 0x%0X\n", byte, received);
+				UartWrite(serial_handle, (UINT8*)"\x00", 1); // ack fail, try again
+			}
+		}
+		else
+			break; // no loop
+	}
+	return 1;
+}
+
+
+// download our little monitor, the box must have been just freshly switched on for this to work
+int DownloadMonitor(tUartHandle serial_handle, bool bRecorder, char* szFilename)
+{
+	FILE* pFile;
+	size_t filesize;
+	UINT8 byte;
+	unsigned i;
+
+	// hard-coded parameters
+	bool bAck = true; // configure if acknowledged download (without useful for remote pin boot)
+	UINT32 TargetLoad = 0x0FFFF000; // target load address
+
+	pFile = fopen(szFilename, "rb");
+	if (pFile == NULL)
+	{
+		printf("\nMonitor file %s not found, exiting\n", szFilename);
+		exit(1);
+	}
+
+	// determine file size
+	fseek(pFile, 0, SEEK_END);
+	filesize = ftell(pFile);
+	fseek(pFile, 0, SEEK_SET);
+
+	// This is _really_ tricky! The box expects a BRR value in a nonstandard baudrate,
+	//	which a PC can't generate. I'm using a higher one with some wild settings
+	//	to generate a pulse series that:
+	//	1) looks like a stable byte when sampled with the nonstandard baudrate
+	//	2) gives a BRR value to the box which results in a baudrate the PC can also use
+	if (bRecorder)
+	{
+		ConfigFirstlevelRecorder(serial_handle);
+	}
+	else
+	{
+		ConfigFirstlevelPlayer(serial_handle);
+	}
+
+	UartWrite(serial_handle, bAck ? (UINT8*)"\x01" : (UINT8*)"\x00", 1); // ACK mode
+
+	// transmit the size, little endian
+	DownloadByte(serial_handle, (UINT8)( filesize	   & 0xFF), bAck);
+	DownloadByte(serial_handle, (UINT8)((filesize>>8)  & 0xFF), bAck);
+	DownloadByte(serial_handle, (UINT8)((filesize>>16) & 0xFF), bAck);
+	DownloadByte(serial_handle, (UINT8)((filesize>>24) & 0xFF), bAck);
+
+	// transmit the load address, little endian
+	DownloadByte(serial_handle, (UINT8)( TargetLoad 	 & 0xFF), bAck);
+	DownloadByte(serial_handle, (UINT8)((TargetLoad>>8)  & 0xFF), bAck);
+	DownloadByte(serial_handle, (UINT8)((TargetLoad>>16) & 0xFF), bAck);
+	DownloadByte(serial_handle, (UINT8)((TargetLoad>>24) & 0xFF), bAck);
+
+	// transmit the command byte
+	DownloadByte(serial_handle, 0xFF, bAck); // 0xFF means execute the transferred image
+
+	// transmit the image
+	for (i=0; i<filesize; i++)
+	{
+		fread(&byte, 1, 1, pFile);
+		DownloadByte(serial_handle, byte, bAck);
+	}
+
+	fclose (pFile);
+
+	// now the image should have been started, red LED off
+
+	return 0;
+}
+
+
+// wait for a fixed string to be received (no foolproof algorithm,
+//	may overlook if the searched string contains repeatitions)
+int WaitForString(tUartHandle serial_handle, char* pszWait)
+{
+	int i = 0;
+	unsigned char received;
+	
+	while(pszWait[i] != '\0')
+	{
+		UartRead(serial_handle, &received, 1);
+
+		printf("%c", received); // debug
+
+		if (received == pszWait[i])
+			i++; // continue
+		else 
+			i=0; // mismatch, start over
+	}
+	return 0;
+}
+
+
+// send a sting and check the echo
+int SendWithEcho(tUartHandle serial_handle, char* pszSend)
+{
+	int i = 0;
+	unsigned char received;
+	
+	while(pszSend[i] != '\0')
+	{
+		UartWrite(serial_handle, (unsigned char*)(pszSend + i), 1); // send char
+		do
+		{
+			UartRead(serial_handle, &received, 1); // receive echo
+			printf("%c", received); // debug
+		}
+		while (received != pszSend[i]); // should normally be equal
+		i++; // next char
+	}
+	return 0;
+}
+
+
+// rarely used variant: download our monitor using the built-in Archos monitor
+int DownloadArchosMonitor(tUartHandle serial_handle, char* szFilename)
+{
+	FILE* pFile;
+	size_t filesize;
+	UINT8 byte;
+	UINT16 checksum = 0;
+	unsigned i;
+
+	// the onboard monitor uses 115200 baud
+	if(!UartConfig(serial_handle, 115200, eNOPARITY, eONESTOPBIT, 8))
+	{
+		UINT32 dwErr = GET_LAST_ERR();
+		printf("Error %d setting up COM params for baudrate %d\n", dwErr, 115200);
+		exit(1);
+	}
+
+	// wait for receiving "#SERIAL#"
+	WaitForString(serial_handle, "#SERIAL#");
+	
+	// send magic "SRL" command to get interactive mode
+	SendWithEcho(serial_handle, "SRL\r");
+	
+	// wait for menu completion: "ROOT>" at the end
+	WaitForString(serial_handle, "ROOT>");
+	
+	// send upload command "UP"
+	SendWithEcho(serial_handle, "UP\r");
+	
+	pFile = fopen(szFilename, "rb");
+	if (pFile == NULL)
+	{
+		printf("\nMonitor file %s not found, exiting\n", szFilename);
+		exit(1);
+	}
+
+	// determine file size
+	fseek(pFile, 0, SEEK_END);
+	filesize = ftell(pFile);
+	fseek(pFile, 0, SEEK_SET);
+	
+	// calculate checksum
+	for (i=0; i<filesize; i++)
+	{
+		fread(&byte, 1, 1, pFile);
+		checksum += byte;
+	}
+	fseek(pFile, 0, SEEK_SET);
+	
+	// send header
+
+	// size as 32 bit little endian
+	byte = (UINT8)( filesize	  & 0xFF);
+	UartWrite(serial_handle, &byte, 1);
+	byte = (UINT8)((filesize>>8)  & 0xFF);
+	UartWrite(serial_handle, &byte, 1);
+	byte = (UINT8)((filesize>>16) & 0xFF);
+	UartWrite(serial_handle, &byte, 1);
+	byte = (UINT8)((filesize>>24) & 0xFF);
+	UartWrite(serial_handle, &byte, 1);
+
+	// checksum as 16 bit little endian
+	byte = (UINT8)( checksum	  & 0xFF);
+	UartWrite(serial_handle, &byte, 1);
+	byte = (UINT8)((checksum>>8)  & 0xFF);
+	UartWrite(serial_handle, &byte, 1);
+	
+	UartWrite(serial_handle, (unsigned char*)"\x00", 1); // kind (3 means flash)
+	UartWrite(serial_handle, (unsigned char*)"\x00", 1); // ignored byte
+
+	// wait for monitor to accept data
+	WaitForString(serial_handle, "#OKCTRL#");
+	
+	// transmit the image
+	for (i=0; i<filesize; i++)
+	{
+		fread(&byte, 1, 1, pFile);
+		UartWrite(serial_handle, &byte, 1); // payload
+	}
+	fclose (pFile);
+	
+	UartWrite(serial_handle, (unsigned char*)"\x00", 1); // ignored byte
+
+	// wait for menu completion: "ROOT>" at the end
+	WaitForString(serial_handle, "ROOT>");
+
+	// send start program command "SPRO"
+	SendWithEcho(serial_handle, "SPRO\r");
+
+	SLEEP(100); // wait a little while for startup
+
+	return 0;
+}
+
+
+/********** Target functions using the Monitor Protocol **********/
+
+// read a byte using the target monitor
+UINT8 ReadByte(tUartHandle serial_handle, UINT32 addr)
+{
+	UINT8 send;
+	UINT8 received;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	// send the read command
+	send = BYTE_READ;
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+
+	return received;
+}
+
+
+// write a byte using the target monitor
+int WriteByte(tUartHandle serial_handle, UINT32 addr, UINT8 byte)
+{
+	UINT8 send;
+	UINT8 received;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error, receiced 0x%02X!\n", received);
+		return 1;
+	}
+
+	// send the write command
+	send = BYTE_WRITE;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the data
+	UartWrite(serial_handle, &byte, 1);
+	
+	UartRead(serial_handle, &received, 1); // response
+
+	if (received != BYTE_WRITE)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+
+// read many bytes using the target monitor
+int ReadByteMultiple(tUartHandle serial_handle, UINT32 addr, UINT32 size, UINT8* pBuffer)
+{
+	UINT8 send, received;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	while (size)
+	{
+		if (size >= 16)
+		{	// we can use a "burst" command
+			send = BYTE_READ16;
+			UartWrite(serial_handle, &send, 1); // send the read command
+			UartRead(serial_handle, pBuffer, 16); // data response
+			pBuffer += 16;
+			size -= 16;
+		}
+		else
+		{	// use single byte command
+			send = BYTE_READ;
+			UartWrite(serial_handle, &send, 1); // send the read command
+			UartRead(serial_handle, pBuffer++, 1); // data response
+			size--;
+		}
+	}
+
+	return 0;
+}
+
+
+// write many bytes using the target monitor
+int WriteByteMultiple(tUartHandle serial_handle, UINT32 addr, UINT32 size, UINT8* pBuffer)
+{
+	UINT8 send, received;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	while (size)
+	{
+		if (size >= 16)
+		{	// we can use a "burst" command
+			send = BYTE_WRITE16;
+			UartWrite(serial_handle, &send, 1); // send the write command
+			UartWrite(serial_handle, pBuffer, 16); // transmit the data
+			UartRead(serial_handle, &received, 1); // response
+			if (received != BYTE_WRITE16)
+			{
+				printf("Protocol error!\n");
+				return 1;
+			}
+			pBuffer += 16;
+			size -= 16;
+		}
+		else
+		{	// use single byte command
+			send = BYTE_WRITE;
+			UartWrite(serial_handle, &send, 1); // send the write command
+			UartWrite(serial_handle, pBuffer++, 1); // transmit the data
+			UartRead(serial_handle, &received, 1); // response
+			if (received != BYTE_WRITE)
+			{
+				printf("Protocol error!\n");
+				return 1;
+			}
+			size--;
+		}
+	}
+
+	return 0;
+}
+
+
+// write many bytes using the target monitor
+int FlashByteMultiple(tUartHandle serial_handle, UINT32 addr, UINT32 size, UINT8* pBuffer)
+{
+	UINT8 send, received;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	while (size)
+	{
+		if (size >= 16)
+		{	// we can use a "burst" command
+			send = BYTE_FLASH16;
+			UartWrite(serial_handle, &send, 1); // send the write command
+			UartWrite(serial_handle, pBuffer, 16); // transmit the data
+			UartRead(serial_handle, &received, 1); // response
+			if (received != BYTE_FLASH16)
+			{
+				printf("Protocol error!\n");
+				return 1;
+			}
+			pBuffer += 16;
+			size -= 16;
+		}
+		else
+		{	// use single byte command
+			send = BYTE_FLASH;
+			UartWrite(serial_handle, &send, 1); // send the write command
+			UartWrite(serial_handle, pBuffer++, 1); // transmit the data
+			UartRead(serial_handle, &received, 1); // response
+			if (received != BYTE_FLASH)
+			{
+				printf("Protocol error!\n");
+				return 1;
+			}
+			size--;
+		}
+	}
+
+	return 0;
+}
+
+
+// read a 16bit halfword using the target monitor
+UINT16 ReadHalfword(tUartHandle serial_handle, UINT32 addr)
+{
+	UINT8 send;
+	UINT8 received;
+	UINT16 halfword;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	// send the read command
+	send = HALFWORD_READ;
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	halfword = received << 8; // highbyte
+	UartRead(serial_handle, &received, 1);
+	halfword |= received; // lowbyte
+
+	return halfword;
+}
+
+
+// write a 16bit halfword using the target monitor
+int WriteHalfword(tUartHandle serial_handle, UINT32 addr, UINT16 halfword)
+{
+	UINT8 send;
+	UINT8 received;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	// send the write command
+	send = HALFWORD_WRITE;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the data
+	send = halfword >> 8; // highbyte
+	UartWrite(serial_handle, &send, 1);
+	send = halfword & 0xFF; // lowbyte
+	UartWrite(serial_handle, &send, 1);
+	
+	UartRead(serial_handle, &received, 1); // response
+
+	if (received != HALFWORD_WRITE)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+
+// change baudrate using target monitor
+int SetTargetBaudrate(tUartHandle serial_handle, long lClock, long lBaudrate)
+{
+	UINT8 send;
+	UINT8 received;
+	UINT8 brr;
+	long lBRR;
+
+	lBRR = lClock / lBaudrate;
+	lBRR = ((lBRR + 16) / 32) - 1; // with rounding
+	brr = (UINT8)lBRR;
+
+	// send the command
+	send = BAUDRATE;
+	UartWrite(serial_handle, &send, 1);
+	UartWrite(serial_handle, &brr, 1); // send the BRR value
+	UartRead(serial_handle, &received, 1); // response ack
+
+	if (received != BAUDRATE)
+	{	// bad situation, now we're unclear about the baudrate of the target
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	SLEEP(100); // give it some time to settle
+
+	// change our baudrate, too
+	UartConfig(serial_handle, lBaudrate, eNOPARITY, eONESTOPBIT, 8); 
+
+	return 0;
+}
+
+
+// call a subroutine using the target monitor
+int Execute(tUartHandle serial_handle, UINT32 addr, bool bReturns)
+{
+	UINT8 send;
+	UINT8 received;
+
+	// send the address command
+	send = ADDRESS;
+	UartWrite(serial_handle, &send, 1);
+
+	// transmit the address, big endian
+	send = (UINT8)((addr>>24) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>16) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)((addr>>8) & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+	send = (UINT8)(addr & 0xFF);
+	UartWrite(serial_handle, &send, 1);
+
+	UartRead(serial_handle, &received, 1); // response
+	if (received != ADDRESS)
+	{
+		printf("Protocol error!\n");
+		return 1;
+	}
+
+	// send the execute command
+	send = EXECUTE;
+	UartWrite(serial_handle, &send, 1);
+	if (bReturns)
+	{	// we expect the call to return control to minimon
+		UartRead(serial_handle, &received, 1); // response
+
+		if (received != EXECUTE)
+		{
+			printf("Protocol error!\n");
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+
diff --git a/flash/uart_boot/client.h b/flash/uart_boot/client.h
new file mode 100644
index 0000000..d2ef29a
--- /dev/null
+++ b/flash/uart_boot/client.h
@@ -0,0 +1,21 @@
+#ifndef _CLIENT_H
+#define _CLIENT_H
+
+
+// setup function for monitor download
+int DownloadMonitor(tUartHandle serial_handle, bool bRecorder, char* szFilename);
+int DownloadArchosMonitor(tUartHandle serial_handle, char* szFilename);
+
+// target functions using the Monitor Protocol
+UINT8 ReadByte(tUartHandle serial_handle, UINT32 addr);
+int WriteByte(tUartHandle serial_handle, UINT32 addr, UINT8 byte);
+int ReadByteMultiple(tUartHandle serial_handle, UINT32 addr, UINT32 size, UINT8* pBuffer);
+int WriteByteMultiple(tUartHandle serial_handle, UINT32 addr, UINT32 size, UINT8* pBuffer);
+int FlashByteMultiple(tUartHandle serial_handle, UINT32 addr, UINT32 size, UINT8* pBuffer);
+UINT16 ReadHalfword(tUartHandle serial_handle, UINT32 addr);
+int WriteHalfword(tUartHandle serial_handle, UINT32 addr, UINT16 halfword);
+int SetTargetBaudrate(tUartHandle serial_handle, long lClock, long lBaudrate);
+int Execute(tUartHandle serial_handle, UINT32 addr, bool bReturns);
+
+
+#endif
\ No newline at end of file
diff --git a/flash/uart_boot/flash.c b/flash/uart_boot/flash.c
new file mode 100644
index 0000000..f27bb7e
--- /dev/null
+++ b/flash/uart_boot/flash.c
@@ -0,0 +1,77 @@
+// flash.cpp : higher-level functions for flashing the chip
+//
+
+#include "scalar_types.h" // (U)INT8/16/32
+#include "Uart.h" // platform abstraction for UART
+#include "client.h" // client functions
+
+
+// read the manufacturer and device ID
+int ReadID(tUartHandle serial_handle, UINT32 base, UINT8* pManufacturerID, UINT8* pDeviceID)
+{
+	base &= 0xFFF80000; // round down to 512k align, to make shure
+
+	WriteByte(serial_handle, base + 0x5555, 0xAA); // enter command mode
+	WriteByte(serial_handle, base + 0x2AAA, 0x55);
+	WriteByte(serial_handle, base + 0x5555, 0x90); // ID command
+	SLEEP(20); // Atmel wants 20ms pause here
+
+	*pManufacturerID = ReadByte(serial_handle, base + 0);
+	*pDeviceID		 = ReadByte(serial_handle, base + 1);
+
+	WriteByte(serial_handle, base + 0, 0xF0);	// reset flash (back to normal read mode)
+	SLEEP(20); // Atmel wants 20ms pause here
+
+	return 0;
+}
+
+
+// erase the sector which contains the given address
+int EraseSector(tUartHandle serial_handle, UINT32 address)
+{
+	UINT32 base = address & 0xFFF80000; // round down to 512k align
+	
+	WriteByte(serial_handle, base + 0x5555, 0xAA); // enter command mode
+	WriteByte(serial_handle, base + 0x2AAA, 0x55);
+	WriteByte(serial_handle, base + 0x5555, 0x80); // eraze command
+	WriteByte(serial_handle, base + 0x5555, 0xAA); // enter command mode
+	WriteByte(serial_handle, base + 0x2AAA, 0x55);
+	WriteByte(serial_handle, address, 0x30); // eraze the sector
+	SLEEP(25); // sector eraze time: 25ms
+
+	return 0;
+}
+
+
+// erase the whole flash
+int EraseChip(tUartHandle serial_handle, UINT32 base)
+{
+	base &= 0xFFF80000; // round down to 512k align, to make shure
+	
+	WriteByte(serial_handle, base + 0x5555, 0xAA); // enter command mode
+	WriteByte(serial_handle, base + 0x2AAA, 0x55);
+	WriteByte(serial_handle, base + 0x5555, 0x80); // eraze command
+	WriteByte(serial_handle, base + 0x5555, 0xAA); // enter command mode
+	WriteByte(serial_handle, base + 0x2AAA, 0x55);
+	WriteByte(serial_handle, base + 0x5555, 0x10); // chip eraze command
+	SLEEP(100); // chip eraze time: 100ms
+
+	return 0;
+}
+
+
+// program a bunch of bytes "by hand"
+int ProgramBytes(tUartHandle serial_handle, UINT32 address, UINT8* pData, UINT32 size)
+{
+	UINT32 base = address & 0xFFF80000; // round down to 512k align
+
+	while (size--)
+	{
+		WriteByte(serial_handle, base + 0x5555, 0xAA); // enter command mode
+		WriteByte(serial_handle, base + 0x2AAA, 0x55);
+		WriteByte(serial_handle, base + 0x5555, 0xA0); // byte program command
+		WriteByte(serial_handle, address++, *pData++);
+		// UART protocol is slow enough such that I don't have to wait 20us here
+	}
+	return 0;
+}
\ No newline at end of file
diff --git a/flash/uart_boot/flash.h b/flash/uart_boot/flash.h
new file mode 100644
index 0000000..70c6201
--- /dev/null
+++ b/flash/uart_boot/flash.h
@@ -0,0 +1,9 @@
+#ifndef _FLASH_H
+#define _FLASH_H
+
+int ReadID(tUartHandle serial_handle, UINT32 base, UINT8* pManufacturerID, UINT8* pDeviceID);
+int EraseSector(tUartHandle serial_handle, UINT32 address);
+int EraseChip(tUartHandle serial_handle, UINT32 base);
+int ProgramBytes(tUartHandle serial_handle, UINT32 address, UINT8* pData, UINT32 size);
+
+#endif
\ No newline at end of file
diff --git a/flash/uart_boot/minimon.h b/flash/uart_boot/minimon.h
new file mode 100644
index 0000000..51406d4
--- /dev/null
+++ b/flash/uart_boot/minimon.h
@@ -0,0 +1,23 @@
+#ifndef _MINIMON_H
+#define _MINIMON_H
+
+
+// Commands
+// all multibyte values (address, halfwords) are passed as big endian 
+//  (most significant of the bytes first)
+
+// set the address (all read/write commands will auto-increment it)
+#define BAUDRATE       0x00 // followed by BRR value; response: command byte
+#define ADDRESS        0x01 // followed by 4 bytes address; response: command byte
+#define BYTE_READ      0x02 // response: 1 byte content
+#define BYTE_WRITE     0x03 // followed by 1 byte content; response: command byte
+#define BYTE_READ16    0x04 // response: 16 bytes content
+#define BYTE_WRITE16   0x05 // followed by 16 bytes; response: command byte
+#define BYTE_FLASH     0x06 // followed by 1 byte content; response: command byte
+#define BYTE_FLASH16   0x07 // followed by 16 bytes; response: command byte
+#define HALFWORD_READ  0x08 // response: 2 byte content
+#define HALFWORD_WRITE 0x09 // followed by 2 byte content; response: command byte
+#define EXECUTE        0x0A // response: command byte if call returns
+
+
+#endif // _MINIMON_H
diff --git a/flash/uart_boot/scalar_types.h b/flash/uart_boot/scalar_types.h
new file mode 100644
index 0000000..88d82c4
--- /dev/null
+++ b/flash/uart_boot/scalar_types.h
@@ -0,0 +1,44 @@
+// this is meant to resolve platform dependency
+
+#ifndef _SCALAR_TYPES_H
+#define _SCALAR_TYPES_H
+
+
+#ifdef WIN32
+#include <windows.h>
+#define SLEEP Sleep
+#define GET_LAST_ERR GetLastError
+#endif
+// ToDo: add stuff for Linux
+
+
+
+#ifndef UINT8
+#define UINT8 unsigned char
+#endif
+
+#ifndef UINT16
+#define UINT16 unsigned short
+#endif
+
+#ifndef UINT32
+#define UINT32 unsigned long
+#endif
+
+#ifndef bool
+#define bool int
+#endif
+
+#ifndef true
+#define true 1
+#endif
+
+#ifndef false
+#define false 0
+#endif
+
+
+
+
+
+#endif
\ No newline at end of file
diff --git a/flash/uart_boot/uart.h b/flash/uart_boot/uart.h
new file mode 100644
index 0000000..46b082c
--- /dev/null
+++ b/flash/uart_boot/uart.h
@@ -0,0 +1,56 @@
+// A general definition for the required UART functionality.
+// This will be used to gain platform abstraction.
+
+#ifndef _UART_H
+#define _UART_H
+
+// data types
+
+typedef void* tUartHandle;
+#define INVALID_UART_HANDLE (tUartHandle)-1
+
+typedef enum
+{
+	eNOPARITY,
+	eODDPARITY, 
+	eEVENPARITY,
+	eMARKPARITY,
+	eSPACEPARITY,
+} tParity;
+
+typedef enum
+{
+	eONESTOPBIT,
+	eONE5STOPBITS,
+	eTWOSTOPBITS,
+} tStopBits;
+
+
+// prototypes
+
+tUartHandle UartOpen(   // returns NULL on error
+	char* szPortName);  // COMx for windows
+
+bool UartConfig(         // returns true on success, false on error
+	tUartHandle handle,  // the handle returned from UartOpen()
+	long lBaudRate,      // must be one of the "standard" baudrates
+	tParity nParity,     // what kind of parity
+	tStopBits nStopBits, // how many stop bits
+	int nByteSize);      // size of the "payload", can be 5 to 8
+
+long UartWrite(           // returns how much data was actually transmitted
+	tUartHandle handle,   // the handle returned from UartOpen()
+	unsigned char* pData, // pointer to the data to be transmitted
+	long lSize);          // how many bytes
+
+long UartRead(              // returns how much data was actually received
+	tUartHandle handle,     // the handle returned from UartOpen()
+	unsigned char* pBuffer, // pointer to the destination
+	long lSize);            // how many bytes to read (pBuffer must have enough room)
+
+
+void UartClose(tUartHandle handle);
+
+
+
+#endif // _UART_H
\ No newline at end of file
diff --git a/flash/uart_boot/uart_boot.c b/flash/uart_boot/uart_boot.c
new file mode 100644
index 0000000..8110e9b
--- /dev/null
+++ b/flash/uart_boot/uart_boot.c
@@ -0,0 +1,337 @@
+// uart_boot.cpp : Defines the entry point for the console application.
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "scalar_types.h" // (U)INT8/16/32
+#include "Uart.h" // platform abstraction for UART
+#include "client.h" // client functions
+#include "flash.h" // flash high level functions
+
+// command line configuration: what shall we do?
+struct
+{
+	char* szPort; // COM port to use
+	bool bRecorder; // it's a recorder
+	bool bArchos; // use the Archos monitor to load, instead of UART boot
+	bool bSpindown; // spindown the harddisk
+	bool bReadID; // read manufacturer+device ID
+	char* szFlashfile; // file to be programmed
+	char* szDumpfile; // file to dump into
+	char* szExecfile; // file with the executable
+	bool bTest; // debug action
+	bool bBlink; // blink red LED
+	bool bNoDownload;
+} gCmd;
+
+
+int ProcessCmdLine(int argc, char* argv[])
+{
+	argc--; // exclude our name
+	argv++;
+
+	memset(&gCmd, 0, sizeof(gCmd));
+
+	if (argc == 0)
+	{
+		printf("Usage: uart_boot [-option {filename}]\n");
+		printf("  uses activated UART boot mod, box has to be fresh started\n");
+		printf("The order of the options does not matter, one letter is sufficient.\n");
+		printf("Possible options are (in the order of later processing):\n");
+		printf("-port <name of COM port to use>\n");
+		printf("-recorder  (this is a recorder/FM, default is player if not specified)\n");
+		printf("-archos  (use Archos bootloader, this one needs powerup while program waits)\n");
+		printf("-nodownload  (no MiniMon download, it's already active)\n");
+		printf("-spindown  (spindown the harddisk, else it stays on by default)\n");
+		printf("-id  (read manufacturer and device ID of flash, no checks)\n");
+		printf("-flash <filename of binary to program into flash>\n");
+		printf("-dump <filename to write flash content to>\n");
+		printf("-exec <filename of executable for 0x09000000:0x09000200>\n");
+		printf("-test  (some test action currently under development, don't use!)\n");
+		printf("-blink (blink red LED forever, meant as diagnostics)\n");
+		printf("\n");
+		printf("Examples:\n");
+		printf("uart_boot -r -p COM1 -s -f flashfile.bin -d dumpfile.bin\n");
+		printf("  recorder on COM1, spindown HD, program and dump (for e.g. offline verify)\n");
+		printf("uart_boot -r -p COM2 -e rockbox.bin\n");
+		printf("  recorder on COM2, load Rockbox from file and start it\n");
+		exit (0);
+	}
+
+
+	while (argc)
+	{
+		if (!strncmp("-port", *argv, 2))
+		{
+			gCmd.szPort = *++argv;
+			if (--argc <= 0 || **argv == '-')
+			{	
+				printf("No argument given for option %s, aborting.\n", argv[-1]);
+				exit (-2);
+			}
+		}
+		else if (!strncmp("-recorder", *argv, 2))
+		{
+			gCmd.bRecorder = true;
+		}
+		else if (!strncmp("-archos", *argv, 2))
+		{
+			gCmd.bArchos = true;
+		}
+		else if (!strncmp("-nodownload", *argv, 2))
+		{
+			gCmd.bNoDownload = true;
+		}
+		else if (!strncmp("-spindown", *argv, 2))
+		{
+			gCmd.bSpindown = true;
+		}
+		else if (!strncmp("-id", *argv, 2))
+		{
+			gCmd.bReadID = true;
+		}
+		else if (!strncmp("-flash", *argv, 2))
+		{
+			gCmd.szFlashfile = *++argv;
+			if (--argc <= 0 || **argv == '-')
+			{	
+				printf("No argument given for option %s, aborting.\n", argv[-1]);
+				exit (-2);
+			}
+		}
+		else if (!strncmp("-dump", *argv, 2))
+		{
+			gCmd.szDumpfile = *++argv;
+			if (--argc <= 0 || **argv == '-')
+			{	
+				printf("No argument given for option %s, aborting.\n", argv[-1]);
+				exit (-3);
+			}
+		}
+		else if (!strncmp("-exec", *argv, 2))
+		{
+			gCmd.szExecfile = *++argv;
+			if (--argc <= 0 || **argv == '-')
+			{	
+				printf("No argument given for option %s, aborting.\n", argv[-1]);
+				exit (-4);
+			}
+		}
+		else if (!strncmp("-test", *argv, 2))
+		{
+			gCmd.bTest = true;
+		}
+		else if (!strncmp("-blink", *argv, 2))
+		{
+			gCmd.bBlink = true;
+		}
+		else
+		{
+			printf("Unknown option %s, aborting. Use 'uart_boot' without options for help.\n", *argv);
+			exit(-1);
+		}
+
+		argv++;
+		argc--;
+	}
+	
+	return 0;
+}
+
+
+int main(int argc, char* argv[])
+{
+	tUartHandle serial_handle;
+	UINT16 reg;
+	FILE* pFile;
+	size_t size;
+	UINT8 abFirmware[512*1024]; // blocksize
+	memset(abFirmware, 0xFF, sizeof(abFirmware));
+
+	ProcessCmdLine(argc, argv); // what to do
+
+	if (!gCmd.szPort)
+	{
+		printf("No serial port given, use 'uart_boot' without parameters for options.\n");
+		exit(-1);
+	}
+
+	serial_handle = UartOpen(gCmd.szPort); // opening serial port
+	if (serial_handle == NULL)
+	{
+		printf("Cannot open port %s\n", gCmd.szPort);
+		return -1;
+	}
+		
+	if (gCmd.bNoDownload)
+	{	// just set our speed
+		if (!UartConfig(serial_handle, gCmd.bRecorder ? 115200 : 14400, eNOPARITY, eONESTOPBIT, 8))
+		{
+			printf("Error setting up COM params\n");
+			exit(1);
+		}
+	}
+	else
+	{	// download the monitor program
+		if (gCmd.bArchos)
+		{
+			printf("Waiting for box startup to download monitor...");
+			DownloadArchosMonitor(serial_handle, "minimon_v2.bin"); // load the monitor image
+			printf("\b\b\b done.\n");
+		}
+		else
+		{
+			printf("Downloading monitor...");
+			DownloadMonitor(serial_handle, gCmd.bRecorder, "minimon.bin"); // load the monitor image
+			// From now on, we can talk to the box.
+			printf("\b\b\b done.\n");
+
+			if (gCmd.bRecorder)
+			{	// we can be faster
+				SetTargetBaudrate(serial_handle, 11059200, 115200); // set to 115200
+			}
+		}
+	}
+
+	// do the action
+
+	if (gCmd.bSpindown)
+	{
+		// spindown the disk (works only for master)
+		UINT32 ata; // address of ATA_ALT_STATUS
+		printf("Harddisk spindown...");
+		ata = (gCmd.bRecorder && (ReadHalfword(serial_handle, 0x020000FC) & 0x0100)) ? 0x06200206 : 0x06200306;
+		WriteHalfword(serial_handle, 0x05FFFFCA, 0xBF99); // PACR2 (was 0xFF99)
+		WriteHalfword(serial_handle, 0x05FFFFC4, 0x0280); // PAIOR (was 0x0000)
+		WriteHalfword(serial_handle, 0x05FFFFC0, 0xA27F); // PADR  (was 0xA0FF)
+		while (ReadByte(serial_handle, ata) & 0x80); // ATA_ALT_STATUS & STATUS_BSY
+		WriteByte(serial_handle, 0x06100107, 0xE0); // ATA_COMMAND = CMD_STANDBY_IMMEDIATE;
+		//while (ReadByte(serial_handle, ata) & 0x80); // ATA_ALT_STATUS & STATUS_BSY
+		printf("\b\b\b done.\n");
+	}
+
+
+	if (gCmd.bReadID)
+	{
+		UINT8 bMan, bID;
+		ReadID(serial_handle, 0x02000000, &bMan, &bID);
+		printf("Manufacturer ID = 0x%02X, Device ID = 0x%02X\n", bMan, bID);
+	}
+
+
+	if (gCmd.szFlashfile)
+	{
+		// flash a firmware file
+		printf("Flashing file %s...", gCmd.szFlashfile);
+		pFile = fopen(gCmd.szFlashfile, "rb");
+		if (pFile == NULL)
+		{
+			printf("\nFlash file %s not found, exiting.\n", gCmd.szFlashfile);
+			return -2;
+		}
+		size = fread(abFirmware, 1, sizeof(abFirmware), pFile);
+		fclose (pFile);
+		
+		EraseChip(serial_handle, 0x02000000);
+		FlashByteMultiple(serial_handle, 0x02000000, size, abFirmware);
+		printf("\b\b\b done.\n");
+	}
+
+
+	if (gCmd.szDumpfile)
+	{
+		// dump the flash content
+		printf("Writing flash dump into file %s...", gCmd.szDumpfile);
+		ReadByteMultiple(serial_handle, 0x02000000, sizeof(abFirmware), abFirmware);
+		pFile = fopen(gCmd.szDumpfile, "wb");
+		if (pFile == NULL)
+		{
+			printf("\nDump file %s cannot be opened, exiting.\n", gCmd.szDumpfile);
+			return -3;
+		}
+		fwrite(abFirmware, 1, sizeof(abFirmware), pFile);
+		fclose (pFile);
+		printf("\b\b\b done.\n");
+	}
+
+
+	if (gCmd.szExecfile)
+	{
+		UINT32 size;
+		
+		printf("Downloading program...");
+
+		// init the DRAM controller like the flash boot does
+		reg = ReadHalfword(serial_handle, 0x05FFFFCA); // PACR2
+		reg &= 0xFFFB; // PA1 config: /RAS
+		reg |= 0x0008;
+		WriteHalfword(serial_handle, 0x05FFFFCA, reg); // PACR2
+		reg = 0xAFFF; // CS1, CS3 config: /CASH. /CASL
+		WriteHalfword(serial_handle, 0x05FFFFEE, reg); // CASCR
+		reg = ReadHalfword(serial_handle, 0x05FFFFA0); // BCR  
+		reg |= 0x8000; // DRAM enable, default bus 
+		WriteHalfword(serial_handle, 0x05FFFFA0, reg); // BCR 
+		reg = ReadHalfword(serial_handle, 0x05FFFFA2); // WCR1	 
+		reg &= 0xFDFD; // 1-cycle CAS 
+		WriteHalfword(serial_handle, 0x05FFFFA2, reg); // WCR1	
+		reg = 0x0E00; // CAS 35%, multiplexed, 10 bit row addr.
+		WriteHalfword(serial_handle, 0x05FFFFA8, reg); // DCR
+		reg = 0x5AB0; // refresh, 4 cycle waitstate
+		WriteHalfword(serial_handle, 0x05FFFFAC, reg); // RCR
+		reg = 0x9605; // refresh constant
+		WriteHalfword(serial_handle, 0x05FFFFB2, reg); // RTCOR
+		reg = 0xA518; // phi/32
+		WriteHalfword(serial_handle, 0x05FFFFAE, reg); // RTCSR
+
+
+		// download Rockbox/gdb
+		pFile = fopen(gCmd.szExecfile, "rb");
+		if (pFile == NULL)
+		{
+			printf("\nExecutable file %s cannot be opened, exiting.\n", gCmd.szExecfile);
+			return -3;
+		}
+
+		size = fread(abFirmware, 1, sizeof(abFirmware), pFile);
+		WriteByteMultiple(serial_handle, 0x09000000, size, abFirmware);
+		fclose (pFile);
+		printf("\b\b\b done.\n");
+
+		// start rockbox/gdb
+		printf("Starting program...");
+		Execute(serial_handle, 0x09000200, false);
+		printf("\b\b\b done.\n");
+	}
+
+
+	if (gCmd.bTest)
+	{
+		// test code: query keypad
+		while (1)
+		{
+			WriteByte(serial_handle, 0x05FFFEE8, 0x24); // ADCSR
+			while (!(ReadByte(serial_handle, 0x05FFFEE8) & 0x80));
+			reg = ReadHalfword(serial_handle, 0x05FFFEE0); // ADDRA
+			printf("ADC(4): %d\n", reg>>6);
+		}
+	}
+
+
+	if (gCmd.bBlink)
+	{
+		// blinking LED
+		UINT8 byte;
+		printf("Flashing red LED forever... (stop with Ctrl-C)\n");
+		byte = ReadByte(serial_handle, 0x05FFFFC3);
+		while (1)
+		{
+			byte ^= 0x40;
+			WriteByte(serial_handle, 0x05FFFFC3, byte);
+			Sleep(200);
+		}
+	}
+
+	return 0;
+}
+
diff --git a/flash/uart_boot/uart_boot.dsp b/flash/uart_boot/uart_boot.dsp
new file mode 100644
index 0000000..4d94c72
--- /dev/null
+++ b/flash/uart_boot/uart_boot.dsp
@@ -0,0 +1,130 @@
+# Microsoft Developer Studio Project File - Name="uart_boot" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=uart_boot - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "uart_boot.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "uart_boot.mak" CFG="uart_boot - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "uart_boot - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "uart_boot - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "uart_boot - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FR /FD /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE RSC /l 0x407 /d "NDEBUG"
+# ADD RSC /l 0x407 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "uart_boot - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /FD /GZ /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE RSC /l 0x407 /d "_DEBUG"
+# ADD RSC /l 0x407 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "uart_boot - Win32 Release"
+# Name "uart_boot - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\client.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\flash.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\uart_boot.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\uart_win.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\flash.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\minimon.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scalar_types.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\uart.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/flash/uart_boot/uart_win.c b/flash/uart_boot/uart_win.c
new file mode 100644
index 0000000..243017a
--- /dev/null
+++ b/flash/uart_boot/uart_win.c
@@ -0,0 +1,138 @@
+// UART wrapper implementation for the Win32 platform
+// make a new version of this file for different systems, e.g. Linux
+
+#include <windows.h>
+#include "scalar_types.h" // (U)INT8/16/32
+#include "Uart.h"
+
+// COMx for windows, returns NULL on error
+tUartHandle UartOpen(char* szPortName)
+{
+	HANDLE serial_handle; 
+	DCB  dcb;
+	COMMTIMEOUTS cto = { 0, 0, 0, 0, 0 };
+
+	memset(&dcb,0,sizeof(dcb));
+
+	/* -------------------------------------------------------------------- */
+	// set DCB to configure the serial port
+	dcb.DCBlength       = sizeof(dcb);
+
+	dcb.fOutxCtsFlow    = 0;
+	dcb.fOutxDsrFlow    = 0;
+	dcb.fDtrControl     = DTR_CONTROL_ENABLE; // enable for power
+	dcb.fDsrSensitivity = 0;
+	dcb.fRtsControl     = RTS_CONTROL_ENABLE; // enable for power
+	dcb.fOutX           = 0;
+	dcb.fInX            = 0;
+
+	/* ----------------- misc parameters ----- */
+	dcb.fErrorChar      = 0;
+	dcb.fBinary         = 1;
+	dcb.fNull           = 0;
+	dcb.fAbortOnError   = 0;
+	dcb.wReserved       = 0;
+	dcb.XonLim          = 2;
+	dcb.XoffLim         = 4;
+	dcb.XonChar         = 0x13;
+	dcb.XoffChar        = 0x19;
+	dcb.EvtChar         = 0;
+
+	/* ----------------- defaults ----- */
+	dcb.BaudRate = 4800;
+	dcb.Parity   = NOPARITY;
+	dcb.fParity  = 0;
+	dcb.StopBits = ONESTOPBIT;
+	dcb.ByteSize = 8;
+
+
+	/* -------------------------------------------------------------------- */
+	// opening serial port
+	serial_handle = CreateFile(szPortName, GENERIC_READ | GENERIC_WRITE,
+		0, NULL, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH, NULL);
+
+	if (serial_handle == INVALID_HANDLE_VALUE)
+	{
+		//printf("Cannot open port \n");
+		return NULL;
+	}
+
+	SetCommMask(serial_handle, 0);
+	SetCommTimeouts(serial_handle, &cto);
+
+	if(!SetCommState(serial_handle, &dcb))
+	{
+		//printf("Error setting up COM params\n");
+		CloseHandle(serial_handle);
+		return NULL;
+	}
+
+	return serial_handle;
+}
+
+// returns true on success, false on error
+bool UartConfig(tUartHandle handle, long lBaudRate, tParity nParity, tStopBits nStopBits, int nByteSize)
+{
+	DCB  dcb;
+	
+	if (!GetCommState (handle, &dcb))
+	{
+		return false;
+	}
+
+	dcb.BaudRate = lBaudRate;
+	dcb.Parity	 = nParity;
+	dcb.StopBits = nStopBits;
+	dcb.ByteSize = nByteSize;
+
+	if(!SetCommState(handle, &dcb))
+	{
+		//DWORD dwErr = GetLastError();
+		//printf("Error %d setting up COM params for baudrate byte\n", dwErr);
+		return false;
+	}
+
+	return true;
+}
+
+// returns how much data was actually transmitted
+long UartWrite(tUartHandle handle, unsigned char* pData, long lSize)
+{
+	BOOL success;
+	DWORD result_nbr;
+
+	success = WriteFile(handle, pData, lSize, &result_nbr, NULL);
+
+	if(!success)
+	{
+		return 0;
+	}
+
+	return result_nbr;
+}
+
+// returns how much data was actually received
+long UartRead(tUartHandle handle, unsigned char* pBuffer, long lSize)
+{
+	BOOL success;
+	DWORD read_nbr;
+
+	success = ReadFile(handle, pBuffer, lSize, &read_nbr, NULL);
+	if(!success)
+	{
+		return 0;
+	}
+
+	return read_nbr;
+}
+
+
+void UartClose(tUartHandle handle)
+{
+	if (handle != NULL)
+	{
+		CloseHandle(handle);
+	}
+
+	return;
+}