#include <bsp/residual.h>
#include <stdint.h>

/* Magic knowledge - qemu loads image here. 
 * However, we use the value from NVRAM if possible...
 */
#define KERNELBASE 0x01000000

/* When starting qemu make sure to give the correct
 * amount of memory!
 *
 * NOTE: Code now supports reading the actual memory
 *       amount from NVRAM. The residual copy in RAM
 *       is fixed-up accordingly.
 */
#define MEM_MEGS 32

/* Mock up a minimal/fake residual; just enough to make the
 * bootloader happy.
 */
struct fake_data {
	unsigned long dat_len;
	unsigned long res_off;
	unsigned long cmd_off;
	unsigned long cmd_len;
	unsigned long img_adr;
	RESIDUAL      fake_residual;
	char          cmdline[1024];
} fake_data = {
dat_len: sizeof(fake_data),
res_off: (unsigned long) &fake_data.fake_residual
        -(unsigned long) &fake_data,
cmd_off: (unsigned long) &fake_data.cmdline
        -(unsigned long) &fake_data,
cmd_len: sizeof(fake_data.cmdline),
img_adr: KERNELBASE,
fake_residual: 
{
  ResidualLength: sizeof(RESIDUAL),
  Version:          0,
  Revision:         0,
  EC:               0,
  VitalProductData: {
	FirmwareSupplier:  QEMU,
	ProcessorHz:    300000000, /* fantasy */
	ProcessorBusHz: 100000000, /* qemu timebase clock */
	TimeBaseDivisor:1*1000,
  },
  MaxNumCpus:       1,
  ActualNumCpus:    1,
  Cpus: {
    {
	CpuType:        0x00040103, /* FIXME: fill from PVR */
	CpuNumber:      0,  
    CpuState:       0,
    },
  },
  /* Memory */
  TotalMemory:      1024*1024*MEM_MEGS,
  GoodMemory:       1024*1024*MEM_MEGS,
  ActualNumMemSegs: 13,
  Segs: {
    { 0x2000, 0xFFF00, 0x00100 },
    { 0x0020, MEM_MEGS*0x100, 0x80000 - MEM_MEGS*0x100 },
    { 0x0008, 0x00800, 0x00168 },
    { 0x0004, 0x00000, 0x00005 },
    { 0x0001, 0x006F1, 0x0010F },
    { 0x0002, 0x006AD, 0x00044 },
    { 0x0010, 0x00005, 0x006A8 },
    { 0x0010, 0x00968, MEM_MEGS*0x100 - 0x00968 },
    { 0x0800, 0xC0000, 0x3F000 },
    { 0x0600, 0xBF800, 0x00800 },
    { 0x0500, 0x81000, 0x3E800 },
    { 0x0480, 0x80800, 0x00800 },
    { 0x0440, 0x80000, 0x00800 }  
  },
  ActualNumMemories: 0,
  Memories: {
	{0},
  },
  /* Devices */
  ActualNumDevices:  1,
  Devices: {
	{
	DeviceId: {
		BusId:     PROCESSORDEVICE,
		BaseType:  BridgeController,
		SubType:   PCIBridge,
		Interface: PCIBridgeIndirect,
	},
	}
  },
  DevicePnPHeap: {0}
},
/* This is overwritten by command line passed by qemu. */
cmdline: {
	'-','-','n','e','2','k','-','i','r','q','=','9',
	0,
}
};

/* Read one byte from NVRAM */
static inline uint8_t
nvram_rd(void)
{
uint8_t rval = *(volatile uint8_t*)0x80000077;
	asm volatile("eieio");
	return rval;
}

/* Set NVRAM address pointer */
static inline void
nvram_addr(uint16_t addr)
{
	*(volatile uint8_t*)0x80000074 = (addr & 0xff);
	asm volatile("eieio");
	*(volatile uint8_t*)0x80000075 = ((addr>>8) & 0xff);
	asm volatile("eieio");
}

/* Read a 32-bit (big-endian) work from NVRAM */
static uint32_t
nvram_rdl_be(uint16_t addr)
{
int i;
uint32_t rval = 0;
	for ( i=0; i<sizeof(rval); i++ ) { 
		nvram_addr( addr + i );
		rval = (rval<<8) | nvram_rd();
	}
	return rval;
}


/* !!! NOTE !!!
 *
 * We use a special hack to propagate command-line info to the bootloader.
 * This is NOT PreP compliant (but who cares).
 * We set R6 and R7 to point to the start/end of the command line string
 * and hacked the bootloader so it uses R6/R7 (provided that the firmware
 * is detected as 'QEMU').
 *
 * (see bootloader/mm.c, bootloader/misc.c,  bootloader/bootldr.h, -- boot_data.cmd_line[])
 */
uint32_t
res_copy(void)
{
struct   fake_data *p;
uint32_t addr, cmdl, l, imga;
uint32_t mem_sz, pgs;
int      i;
int      have_nvram;

	/* Make sure we have a valid NVRAM -- just check for 'QEMU' at the
	 * beginning 
	 */
	have_nvram = ( (('Q'<<24) | ('E'<<16) | ('M'<< 8) | ('U'<< 0)) == nvram_rdl_be( 0x0000 ) );

	if ( !have_nvram ) {
		/* reading NVRAM failed - fall back to using the static residual copy;
		 * this means no support for variable memory size or 'true' command line.
		 */
		return (uint32_t)&fake_data;
	}

	/* Dilemma - we don't really know where to put the residual copy
     * (original is in ROM and cannot be modified).
	 * We can't put it at the top of memory since the bootloader starts
	 * allocating memory from there, before saving the residual, that is.
	 * Too close to the final image might not work either because RTEMS
	 * zeroes its BSS *before* making its copies of the residual and commandline.
	 *
 	 * For now we hope that appending to the kernel image works (and that
	 * the bootloader puts it somewhere safe).
	 */
	imga  = nvram_rdl_be( 0x0038 );
	addr  = imga + nvram_rdl_be( 0x003c );
	addr += 0x1f;
	addr &= ~(0x1f);

	p     = (struct fake_data *)addr;

	/* commandline + length from NVRAM */
	cmdl  = nvram_rdl_be( 0x0040 );
	l     = nvram_rdl_be( 0x0044 );

	if ( l > 0 ) {
		/* have a command-line; copy it into our local buffer */
		if ( l > sizeof( p->cmdline ) - 1 ) {
			l = sizeof( p->cmdline ) - 1;
		}
		/* original may overlap our buffer; must safely move around */
		if ( p->cmdline < (char*)cmdl ) {
			for ( i=0; i<l; i++ ) {
				p->cmdline[i] = ((char*)cmdl)[i];
			}
		} else {
			for ( i=l-1; i>=0; i-- ) {
				p->cmdline[i] = ((char*)cmdl)[i];
			}
		}
	}
	p->cmdline[l]      = 0;
	/* Copy rest of residual */
	for ( i=0; i<sizeof(p->fake_residual); i++ )
		((char*)&p->fake_residual)[i] = ((char*)&fake_data.fake_residual)[i];
	p->dat_len         = fake_data.dat_len;
	p->res_off         = fake_data.res_off;
	p->cmd_off         = fake_data.cmd_off;
	p->cmd_len         = l+1;
	p->img_adr         = imga;

	/* Fix up memory in residual from NVRAM settings */

	mem_sz = nvram_rdl_be( 0x0030 );
	pgs    = mem_sz >> 12;

	p->fake_residual.TotalMemory = mem_sz;
	p->fake_residual.GoodMemory  = mem_sz;

	p->fake_residual.Segs[1].BasePage  = pgs;
	p->fake_residual.Segs[1].PageCount = 0x80000 - pgs;
	p->fake_residual.Segs[7].PageCount = pgs - 0x00968;

	return (uint32_t)p;
}