#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdint.h>

#ifndef SDRAM_BASE
#define SDRAM_BASE			0x40000000
#endif
#ifndef FLASH_BASE_MEM
#define FLASH_BASE_MEM		0x00000000
#endif

#define	MAGIC		0x4A464931	// "JFI1" in big-endian;

uint8_t _g_bytes[4] = {0x12, 0x34, 0x56, 0x78};
uint8_t _g_bytes2[4] = {0};

int IsEndianBig(void)
{
	int i, result;

	uint8_t *pBuf8;
	uint16_t *pBuf16;
	uint32_t *pBuf32;
	uint16_t halve;
	uint32_t word;


	halve = 0x1234;
	word = 0x12345678;

	result = -1;

	for (i=0; i < 4; i++)
		_g_bytes2[i] = _g_bytes[i];

	pBuf8 = (uint8_t*)&word;
	if (((*pBuf8+0) == 0x12) && (*(pBuf8+1) == 0x34) && (*(pBuf8+2) == 0x56) && (*(pBuf8+3) == 0x78))
	{
		pBuf8 = (uint8_t*)&halve;
		if (((*pBuf8+0) == 0x12) && (*(pBuf8+1) == 0x34))
		{
			result = 1;
		}
	}

	pBuf8 = (uint8_t*)&word;
	if (((*pBuf8+0) == 0x78) && (*(pBuf8+1) == 0x56) && (*(pBuf8+2) == 0x34) && (*(pBuf8+3) == 0x12))
	{
		pBuf8 = (uint8_t*)&halve;
		if (((*pBuf8+0) == 0x34) && (*(pBuf8+1) == 0x12))
		{
			result = 0;
		}
	}
	return result;
}

uint32_t conv_endian32(uint32_t src)
{
	uint32_t dst;

	dst = (0xFF000000 & (src << 24))
		| (0x00FF0000 & (src << 8))
		| (0x0000FF00 & (src >> 8))
		| (0x000000FF & (src >> 24));

	return dst;
};

// --------------------------------------------------------------
typedef struct _sflash_img_hdr_t
{
	uint32_t magic;
	uint32_t target_addr;
	uint32_t img_offset;
	uint32_t img_size;
	uint32_t hdr_next;
	uint8_t img_name[128];
	uint8_t res[108];

} flash_img_hdr_t;

// --------------------------------------------------------------
void basename(char *pSrc, char *pDst)
{
	int i, size;

	size = strlen(pSrc);

	while(pSrc[size] != '.')
		size--;

	for (i=0; i < size; i++)
		pDst[i] = pSrc[i];

	pDst[i] = 0;

}

// --------------------------------------------------------------
int main(int argc, char *argv[])
{
	char *pFilenameIn;
	char name_flash[1024];
	char name_prj[1024];
	char *pBuf;
	uint32_t *pBuf32;
	flash_img_hdr_t img_hdr = {0};

	FILE *pFile;
	int filesize;
	long start, end;
	int i;

	if (argc < 2)
	{
		fprintf(stderr, "Usage: flashgen <input file> [-{EL|EB}]\n");
		return 1;
	}

	pFilenameIn = argv[1];
	pFile = fopen(pFilenameIn, "rb");
	if (!pFile)
	{
		fprintf(stderr, "Error opening file %s\n", pFilenameIn);
		return 1;
	}

	basename(pFilenameIn, name_prj);
	sprintf(name_flash, "%s.flash.bin", name_prj);

	// determine filesize
	fseek(pFile, 0, SEEK_SET);
	start = ftell(pFile);
	fseek(pFile, 0, SEEK_END);
	end = ftell(pFile);
	fseek(pFile, 0, SEEK_SET);
	filesize = (end-start);

	pBuf = (char*)malloc(filesize);
	filesize = fread(pBuf, 1, filesize, pFile);

	fclose(pFile);

	pFile = fopen(name_flash, "wb");
	if (!pFile)
	{
		fprintf(stderr, "Error opening file %s\n", name_flash);
		return 1;
	}

	img_hdr.magic = MAGIC;

	img_hdr.target_addr = SDRAM_BASE;
	img_hdr.img_size = filesize;
	img_hdr.img_offset = FLASH_BASE_MEM + sizeof(flash_img_hdr_t);
	img_hdr.hdr_next = FLASH_BASE_MEM;

	if (argc == 3)
	{
		if ((argv[2][0] == '-') && (toupper(argv[2][1]) == 'E') && (toupper(argv[2][2]) == 'B'))
		{
			if (1 == IsEndianBig())
			{
				img_hdr.magic = conv_endian32(MAGIC);
				pBuf32 = (uint32_t*)pBuf;
				for (i=0; i < filesize/4; i ++)
					pBuf32[i] = pBuf32[i];			// don't convert data
			}
			else
			{
				pBuf32 = (uint32_t*)pBuf;
				for (i=0; i < filesize/4; i ++)
					pBuf32[i] = conv_endian32(pBuf32[i]);	// convert data
			}
		}
	}
	fwrite(&img_hdr, sizeof(flash_img_hdr_t), 1, pFile);
	fwrite(pBuf, 1, filesize, pFile);

	fclose(pFile);

	return 0;
}