amt630h-sdk-beta/AMTLDR/Src/SpiBooter.c

#include <string.h>
#include "typedef.h"
#include "amt630h.h"
#include "UartPrint.h"
#include "timer.h"
#include "spi.h"
#include "cp15.h"
#include "sysinfo.h"
#include "crc32.h"
#include "gpio.h"

#define SPI_CS_GPIO		32

#define SPI_RXFIFO_FULL				(1<<4)
#define SPI_RXFIFO_NOTEMPTY			(1<<3)
#define SPI_TXFIFO_EMPTY			(1<<2)
#define SPI_TXFIFO_NOTFULL			(1<<1)
#define SPIFLASH_BUSY				(1<<0)

static void SetCSGpioEnable(int enable)
{       
	gpio_direction_output(SPI_CS_GPIO, !enable);
}

static void SetSpiDataMode(unsigned int bitMode)
{
	unsigned int val = 0;
	
	(void)val;
	while((rSPI_SR & SPI_BUSY));
	rSPI_SSIENR = 0;
	val = rSPI_CTLR0;
	val &=~(0x1f<<16);
	val |=((bitMode-1)<<16);
	rSPI_CTLR0 = val;
	rSPI_SSIENR = 1;
}

static void SpiEmptyRxFIFO(void)
{
	INT32 data = 0;

	(void)data;
	
	while(rSPI_SR & SPI_RXFIFO_NOTEMPTY)
		data = rSPI_DR;
}

static UINT8 SpiReadSta(void)
{
	UINT8 status;

	SetSpiDataMode(8);
	SetCSGpioEnable(1);
	rSPI_DR = SPI_READ_STATUS;
	rSPI_DR = 0;
	while(!(rSPI_SR & SPI_RXFIFO_NOTEMPTY));
	status = rSPI_DR;
	while(!(rSPI_SR & SPI_RXFIFO_NOTEMPTY));
	status = rSPI_DR;
	//PrintVariableValueHex("status:", status);
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);
	SetSpiDataMode(32);
	return status;
}

static void SpiReadPage(UINT32 pagenum, UINT32 *buf)
{
	UINT32 addr;
	UINT32 val = 0;
	INT32 i;
	UINT8 tmpaddr[3];

	(void)val;
	  
	addr = pagenum*BYTESPERPAGE;
	tmpaddr[0] = addr;
	tmpaddr[1] = addr>>8;
	tmpaddr[2] = addr>>16;

	SpiEmptyRxFIFO(); 
	SetCSGpioEnable(1);

	rSPI_DR = (tmpaddr[0]<<24) | (tmpaddr[1]<<16) | (tmpaddr[2]<<8) | SPI_READ_DATA;
		
	for(i=0;i<WORDSPERPAGE;i++)
	{ 
		while(!(rSPI_SR & SPI_TXFIFO_NOTFULL));  
		rSPI_DR = 0;
	}
        
	while(!(rSPI_SR & SPI_RXFIFO_NOTEMPTY)); 
	val = rSPI_DR;
	for(i = 0; i < WORDSPERPAGE; i++)
	{   
		while(!(rSPI_SR & SPI_RXFIFO_NOTEMPTY));                   
		*buf++ = rSPI_DR;
	}
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);
}

void SpiSelectPad()
{
	UINT32 val;
	val = rSYS_PAD_CTRL02;
	val &= ~0xfff;
	val |= (0x1<<10)|(0x1 << 8)|(0x1 << 6)|(0x1 << 4)| (0x1 << 2);
	rSYS_PAD_CTRL02 = val;    
	
	val = rSYS_SSP_CLK_CFG;
	val &= ~((0x1<<31)|(0x1<<30));
	val |= (0x1<<31)|(0x1<<30);	
	rSYS_SSP_CLK_CFG = val;

	//cs inactive first
	SetCSGpioEnable(0);
}

void Reset(void)
{
	SetSpiDataMode(8);
	rSPI_DR = 0x66;
	while((SpiReadSta() & SPI_BUSY));
//	while(!(SpiReadSta() & SPIFLASH_WRITEENABLE));
	rSPI_DR = 0x99;
	while((SpiReadSta() & SPI_BUSY));
//	while(!(SpiReadSta() & SPIFLASH_WRITEENABLE));	
	
	SetSpiDataMode(32);
}

void SpiInit()
{
	unsigned int val;
	val = rSYS_SOFT_RST;
	val &= ~(0x1<<8);
	rSYS_SOFT_RST = val;
	udelay(10);
	val |= (0x1<<8);
	rSYS_SOFT_RST = val;

	rSPI_SSIENR = 0;
	rSPI_CTLR0 = 0;
	rSPI_CTLR0 |=(0<<21)|(0x1f<<16)|(0x0<<12)|(0x0<<8)|(0x0<<4); 
	//  rSPI_CTLR1 = 63;
	rSPI_BAUDR = 4;//42;//16;//2;
	rSPI_SER = 1;
	rSPI_SSIENR = 1;	

//	Reset();
}

static void SpiReadDeviceId(UINT8 *mfid, UINT8 *devid)
{
	UINT8 val[6];
	int i;
	SetSpiDataMode(8);
	SetCSGpioEnable(1);
    rSPI_DR = SPI_MF_DEVICE_ID;
	rSPI_DR = 0;
	rSPI_DR = 0;
	rSPI_DR = 0;
	rSPI_DR = 0;
	rSPI_DR = 0;	
	for (i = 0; i < 6; i++)
	{
		while(!(rSPI_SR & SPI_RXFIFO_NOTEMPTY));	
		val[i] = rSPI_DR;	  
	}  
	*mfid = val[4];
	*devid = val[5];
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);
	SetSpiDataMode(32);
}

static void SpiReadJedecId(UINT8 *mfid, UINT8 *memid, UINT8 *capid)
{
	UINT8 val[4];
	int i;

	SetSpiDataMode(8);
	SetCSGpioEnable(1);
    rSPI_DR = SPI_READ_JEDEC_ID;
	rSPI_DR = 0;
	rSPI_DR = 0;
	rSPI_DR = 0;
	
	for (i = 0; i < 4; i++)
	{
		while(!(rSPI_SR & SPI_RXFIFO_NOTEMPTY));	
		val[i] = rSPI_DR;	  
	}  
	*mfid = val[1];
	*memid = val[2];
	*capid = val[3];
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);
	SetSpiDataMode(32);  
}

void SpiReadId(void)
{
	UINT8 mfid,devid,memid,capid;

	SpiReadDeviceId(&mfid,&devid);
	SpiReadJedecId(&mfid,&memid,&capid);
	PrintVariableValueHex("ManufacturerID: ", mfid);
	PrintVariableValueHex("DeviceID: ", devid);	
	PrintVariableValueHex("Memory Type ID: ", memid);
	PrintVariableValueHex("Capacity ID: ", capid);
}

#define SPI_READ_MAXLEN		BYTESPERPAGE

static void SpiLoadStepldr(void (*readfunc)(UINT32, UINT32 *))
{
	unsigned int i = 0;
	UINT32 *buf = (UINT32*)STEPLDR_ENTRY;
	UINT32 offset;
	UINT32 size;
	UINT32 nPageCount;
	UINT32 nPageStart;
	
	if (ReadSysInfo()) {
		SendUartString("read sysinfo fail, try to load stepldr part a.\n");
		offset = STEPLDRA_OFFSET;
		size = STEPLDR_MAX_SIZE;
	} else {
		SysInfo *sysinfo = GetSysInfo();
		offset = sysinfo->stepldr_offset;
		size = sysinfo->stepldr_size;
	}
	
	PrintVariableValueHex("stepldr offset: ", offset);
		
	nPageCount = (size + BYTESPERPAGE - 1) / BYTESPERPAGE;
	nPageStart = offset / BYTESPERPAGE;
	for(i = nPageStart; i < nPageStart + nPageCount; i++)
	{
		readfunc(i, buf);
		buf += BYTESPERPAGE/4;
	}
	
#ifdef MMU_ENABLE
	CP15_clean_dcache_for_dma(STEPLDR_ENTRY, STEPLDR_ENTRY + size);
#endif
}

static void SpiWriteEnable(void)
{
	SetSpiDataMode(8);
	SetCSGpioEnable(1);
	rSPI_DR = SPI_WRITE_ENABLE;
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);
	while((SpiReadSta() & SPI_BUSY));
	while(!(SpiReadSta() & SPIFLASH_WRITEENABLE));
	SetSpiDataMode(32);
}

static void SpiEraseSector(UINT32 sectorNum)
{
	UINT32 addr;
	UINT8 tmpaddr[3];

	addr = BYTESPERSECTOR*sectorNum;
	tmpaddr[0] = addr;
	tmpaddr[1] = addr>>8;
	tmpaddr[2] = addr>>16;

	SpiWriteEnable();
	SetCSGpioEnable(1);
	rSPI_DR = (tmpaddr[0]<<24) | (tmpaddr[1]<<16) | (tmpaddr[2]<<8) | SPI_SECTOR_ERASE;
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);
	while((SpiReadSta() & SPIFLASH_WRITEENABLE));
}

static void SpiEraseBlock(UINT32 blockNum)
{
	UINT32 addr;
	UINT8 tmpaddr[3];

	addr = BYTESPERBLOCK*blockNum;
	tmpaddr[0] = addr;
	tmpaddr[1] = addr>>8;
	tmpaddr[2] = addr>>16;

	SpiWriteEnable();
	SetCSGpioEnable(1);
	rSPI_DR = (tmpaddr[0]<<24) | (tmpaddr[1]<<16) | (tmpaddr[2]<<8) | SPI_BLOCK_ERASE;
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);

	while((SpiReadSta() & SPIFLASH_WRITEENABLE));
}

static void SpiWritePage(UINT32 pagenum, UINT32 *buf)
{
    UINT32 addr;
    UINT32 val = 0;;
    INT32 i;
    UINT8 tmpaddr[3];

	(void)val;
	
    addr = pagenum*BYTESPERPAGE;
    tmpaddr[0] = addr;
    tmpaddr[1] = addr>>8;
    tmpaddr[2] = addr>>16;

    SpiWriteEnable(); 
	SetCSGpioEnable(1);
	rSPI_DR = (tmpaddr[0]<<24) | (tmpaddr[1]<<16) | (tmpaddr[2]<<8) | SPI_PAGE_PROGRAM;
    for(i=0;i<WORDSPERPAGE;i++)
    { 
        while(!(rSPI_SR & SPI_TXFIFO_NOTFULL)); 
        rSPI_DR = *buf++;
    }
	while(rSPI_SR & SPIFLASH_BUSY);
	SetCSGpioEnable(0);
    while(SpiReadSta() & SPI_BUSY);
}

void bootFromSPI(void)
{
	void (*funPtr)(void);
	
	SpiLoadStepldr(SpiReadPage);
	
	funPtr = (void (*)(void))STEPLDR_ENTRY;
	funPtr();
}

static unsigned int pagecheck[WORDSPERPAGE];
/* offset is at least align to SECOTR_SIZE */
static int SpiNorBurnPage(int pagenum, unsigned int *buf)
{
	int timeout = 3;
	unsigned int *tmp = (unsigned int *)buf;
	int i;

retry:
	SpiWritePage(pagenum, buf);
	SpiReadPage(pagenum, pagecheck);
	for (i = 0; i < WORDSPERPAGE; i++) {
		if (tmp[i] != pagecheck[i]) {
			if (timeout-- > 0) {
				PrintVariableValueHex("write: ", tmp[i]);
				PrintVariableValueHex("read: ", pagecheck[i]);
				SendUartString("burn check data fail, retry...\r\n");
				goto retry;
			} else {
				SendUartString("burn error!\r\n");
				return -1;
			}
		}
	}

	return 0;
}


/* offset is at least align to SECOTR_SIZE */
int SpiNorBurn(void *buf, unsigned int offset, unsigned int size)
{
  	int i, j;
 	int secstart, secnum;
 	int blkstart, blknum;	
	int pagestart, pageburned;
	int remain = size;
	unsigned int *pbuf = (unsigned int *)buf;

	pagestart = offset / BYTESPERPAGE;
	pageburned = 0;

	while (remain > 0) {
		unsigned int tmp = offset & (BYTESPERBLOCK - 1);
		if (tmp) {
			tmp = (BYTESPERBLOCK - tmp) / BYTESPERSECTOR;
			secnum = (remain + BYTESPERSECTOR - 1) / BYTESPERSECTOR;
			secnum = min(tmp, secnum);
			secstart = offset / BYTESPERSECTOR;
			for (i = 0; i < secnum; i++) {
				SpiEraseSector(secstart + i);
				for (j = 0; j < PAGESPERSECTORS; j++) {
					if (SpiNorBurnPage(pagestart + j, pbuf))
						return -1;
					pbuf += WORDSPERPAGE;
					pageburned++;
					remain -= BYTESPERPAGE;
					if (remain <= 0) goto finish;
				}
				pagestart += PAGESPERSECTORS;
			}
			offset += secnum * BYTESPERSECTOR;
		} else {
			blkstart = offset / BYTESPERBLOCK;
			blknum = remain / BYTESPERBLOCK;
			for (i = 0; i < blknum; i++) {
				SpiEraseBlock(blkstart + i);
				for (j = 0; j < PAGESPERSECTORS * SECTORSPERBLOCK; j++) {
					if (SpiNorBurnPage(pagestart + j, pbuf))
						return -1;
					pbuf += WORDSPERPAGE;
					pageburned++;
					remain -= BYTESPERPAGE;
					if (remain <= 0) goto finish;
				}
				pagestart += PAGESPERSECTORS * SECTORSPERBLOCK;
			}
			offset += blknum * BYTESPERBLOCK;
			if (remain > 0) {
				secstart = offset / BYTESPERSECTOR;
				secnum = (remain + BYTESPERSECTOR - 1) / BYTESPERSECTOR;
				for (i = 0; i < secnum; i++) {
					SpiEraseSector(secstart + i);
					for (j = 0; j < PAGESPERSECTORS; j++) {
						if (SpiNorBurnPage(pagestart + j, pbuf))
							return -1;
						pbuf += WORDSPERPAGE;
						pageburned++;
						remain -= BYTESPERPAGE;
						if (remain <= 0) goto finish;
					}
					pagestart += PAGESPERSECTORS;
				}
				offset += secnum * BYTESPERSECTOR;
			}
		}
	}
finish:
	return 0;
}

int SpiReadSysInfo(SysInfo *info)
{
	UINT32 *buf = (UINT32*)IMAGE_ENTRY;
	int pagestart;
	int pagenum;
	UINT32 checksum;
	UINT32 calc_checksum;
	int i;

	pagestart = SYSINFOA_OFFSET / BYTESPERPAGE;
	pagenum = (sizeof(SysInfo) + BYTESPERPAGE - 1) / BYTESPERPAGE;
	for(i = pagestart; i < pagestart + pagenum; i++)
	{
		SpiReadPage(i, buf);
		buf += BYTESPERPAGE/4;
	}
	
	checksum = *(UINT32*)(IMAGE_ENTRY + sizeof(SysInfo) - 4);
	calc_checksum = xcrc32((unsigned char*)IMAGE_ENTRY, sizeof(SysInfo) - 4, 0xffffffff);
	if (calc_checksum == checksum) {
		memcpy(info, (void*)IMAGE_ENTRY, sizeof(SysInfo));
		return 0;
	}

	buf = (UINT32*)IMAGE_ENTRY;
	pagestart = SYSINFOB_OFFSET / BYTESPERPAGE;
	for(i = pagestart; i < pagestart + pagenum; i++)
	{
		SpiReadPage(i, buf);
		buf += BYTESPERPAGE/4;
	}
	
	checksum = *(UINT32*)(IMAGE_ENTRY + sizeof(SysInfo) - 4);
	calc_checksum = xcrc32((unsigned char*)IMAGE_ENTRY, sizeof(SysInfo) - 4, 0xffffffff);
	if (calc_checksum == checksum) {
		memcpy(info, (void*)IMAGE_ENTRY, sizeof(SysInfo));
		return 0;
	}
	
	return -1;
}

void SpiWriteSysInfo(SysInfo *info)
{
	SpiNorBurn(info, SYSINFOB_OFFSET, sizeof(SysInfo));
	SpiNorBurn(info, SYSINFOA_OFFSET, sizeof(SysInfo));
}