flash/make_firmware/make_firmware.c - rockbox - Gitiles

 /***************************************************************************
  *             __________               __   ___.
  *   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 FLASH_START  0x02000000
 #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;
 	UINT32 load_addr = ROCKBOX_DEST, exec_addr = ROCKBOX_EXEC; // defaults

 	// 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
 			&& ucl_header[12] != 0x2B) // or uncompressed
 		{
 			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
 		}

 		if (ucl_header[12] == 0x2B) // uncompressed means "ROMbox", for direct flash execution
 		{
 			UINT8 reset_vec[4];
 			fread(reset_vec, 1, sizeof(reset_vec), pFile); // read the reset vector from image
 			fseek(pFile, 0-sizeof(reset_vec), SEEK_CUR); // wind back
 			load_addr = FLASH_START + pos + 16; // behind 16 byte header
 			exec_addr = Read32(reset_vec);
 		}
 	}
 	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, load_addr); // load address
 	Write32(pFirmware + pos + 4, align - (pos + 16)); // image size
 	Write32(pFirmware + pos + 8, exec_addr); // 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;
 }
	/***************************************************************************
	* __________ __ ___.
	* 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 FLASH_START 0x02000000
	#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;
	UINT32 load_addr = ROCKBOX_DEST, exec_addr = ROCKBOX_EXEC; // defaults

	// 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
	&& ucl_header[12] != 0x2B) // or uncompressed
	{
	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
	}

	if (ucl_header[12] == 0x2B) // uncompressed means "ROMbox", for direct flash execution
	{
	UINT8 reset_vec[4];
	fread(reset_vec, 1, sizeof(reset_vec), pFile); // read the reset vector from image
	fseek(pFile, 0-sizeof(reset_vec), SEEK_CUR); // wind back
	load_addr = FLASH_START + pos + 16; // behind 16 byte header
	exec_addr = Read32(reset_vec);
	}
	}
	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, load_addr); // load address
	Write32(pFirmware + pos + 4, align - (pos + 16)); // image size
	Write32(pFirmware + pos + 8, exec_addr); // 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;
	}