sif_m25p64.c

umon bootloader source code, support mips cpu.

{    
    while(SflashReadStatus() & 0x1);             // Wait till the internal erase, 
                                                 // program or Status Write ends.
}

/*************************************************************************
 *
 * M25p64_erase():
 * Erase the specified sector on the device specified by the flash info
 * poniter.  Return 0 if success, else negative to indicate device-specific
 * error or reason for failure.
 */
int
M25p64_erase(struct flashinfo *fdev,int snum)
{
    SflashWriteEn();	
    
    SifModeRegSet(SIF_CBUS_MODE, SIF_CS_n0, SIF_CTL_SEL_8BIT, SIF_ADD_SEL_3BYTE, \
                  SIF_WRITE, 0 /* sID */, 0 /* blen */);		
    SifCommandSet(SIF_INSTR_SE);            
    SifAddrSet(fdev->sectors[snum].begin);                   // Write the start address into the register.
    SifStart();        

    return 0;
}

/* EndM25p64_erase():
 * Function place holder to determine the end of the above function.
 */
void
EndM25p64_erase(void)
{}

int
M25p64_write(struct flashinfo *fdev,uchar *dest,uchar *src,
	long bytecnt)
{
    int i;	

    while(SifBusyRead());       // If a transaction doesn't end, new one cannot be started.
    
    for(i = 0; i < bytecnt; i++) {
    	SflashWriteEn();
    
        SifModeRegSet(SIF_CBUS_MODE, SIF_CS_n0, SIF_CTL_SEL_8BIT, SIF_ADD_SEL_3BYTE, \
                      SIF_WRITE, 0 /* sID */, 1 /* blen */);		
        SifCommandSet(SIF_INSTR_PP);            
      
        SifAddrSet(*dest++);       
        
        SifDataWrite(*src++);	
        SifStart();           // Start SPI operation. 
        while(SifBusyRead());
    }    
	
}

/* EndM25p64_write():
 * Function place holder to determine the end of the above fun02n.
 */
void
EndM25p64_write(void)
{}


int
M25p64_type(struct flashinfo *fdev)
{
	fdev->id = 0x202017;
	return((int)(fdev->id));
}

/* EndM25p64_type():
 * Function place holder to determine the end of the above function.
 */
void
EndM25p64_type(void)
{}

/* M25p64_ewrite():
 * Erase all sectors that are part of the address space to be written,
 * then write the data to that address space.  This is basically a
 * concatenation of the above erase & write done in one step.  This is
 * necessary primarily for re-writing the bootcode; because after the boot
 * code is erased, there is nowhere to return so the re-write must be done
 * while executing out of ram also.  It is only needed in systems that are
 * executing the monitor out of the same device that is being updated.
 */
int
M25p64_ewrite(struct flashinfo *fdev,uchar *destA,uchar *srcA,
	long bytecnt)
{
	int	    sector, i;
	void	(*reset)();
	uchar   *src, *dest;

	return(0);	/* won't get here */
}

/* EndM25p64_ewrite():
 * Function place holder to determine the end of the above function.
 */
void
EndM25p64_ewrite(void)
{}

/* M25p64_lock():
 */

int
M25p64_lock(struct flashinfo *fdev,int snum,int operation)
{
		return(0);
}

/* EndM25p64_lock():
 * Function place holder to determine the end of the above function.
 */
void
EndM25p64_lock(void)
{
}


#ifdef SINGLE_FLASH_DEVICE

/* FlashXXXFbuf[]:
 * If FLASH_COPY_TO_RAM is defined then these arrays will contain the
 * flash operation functions above.  To operate on most flash devices,
 * you cannot be executing out of it (there are exceptions, but
 * in general, we do not assume the flash supports this).  The flash
 * functions are copied here, then executed through the function
 * pointers established in the flashinfo structure below.
 * One obvious requirement...  The size of each array must be at least
 * as large as the function that it will contain.
 */
#ifdef FLASH_COPY_TO_RAM
ulong	FlashLockFbuf[400];
ulong	FlashTypeFbuf[400];
ulong	FlashEraseFbuf[400];
ulong	FlashWriteFbuf[400];
ulong	FlashEwriteFbuf[400];
#endif

/* FlashNamId[]:
 * Used to correlate between the ID and a string representing the name
 * of the flash device.
 * Note that this table (and the case statement in FlashBankInit())
 * allow a 28F128 flash ID to sneak by... This is to allow a 28F128
 * device to be put in the footprint of a 28F640, but with the upper
 * half of the device inaccessible (some CSB360 boards).
 */
struct flashdesc FlashNamId[] = {
	{ INTEL_28F640,			"INTEL-28F640" },
	{ ST_M58LW064D,			"SGS_THOMPSON-M58LW064D" },
	{ INTEL_DT28F640J5,		"INTEL-DT28F640J5" },
	{ INTEL_DT28F128J5,		"INTEL-28F128 (half)" },
	{ ST_M25P64,				"ST_M25P64"},
	{ 0, 0 },
};

int
FlashBankInit(struct flashinfo *fbnk,int snum)
{
	uchar	*saddr;
	int		i, msize;
	struct	sectorinfo *sinfotbl;
	
	/* Based on the flash bank ID returned, load a sector count and a
	 * sector size-information table...
	 */
	flashtype(fbnk);
	switch(fbnk->id) {
		case ST_M58LW064D:
		case INTEL_28F640:
		case INTEL_DT28F640J5:
			fbnk->sectorcnt = 64;
			break;
		case ST_M25P64:
		case INTEL_DT28F128J5:	
			fbnk->sectorcnt = 128;
			break;
		default:
			printf("Unrecognized flashid: 0x%08lx\n",fbnk->id);
			return(-1);
			break;
	}

	/* Create the per-sector information table.  The size of the table
	 * depends on the number of sectors in the device...
	 */
	if (fbnk->sectors)
		free((char *)fbnk->sectors);
	msize = fbnk->sectorcnt * (sizeof(struct sectorinfo));
	sinfotbl = (struct sectorinfo *)malloc(msize);
	if (!sinfotbl) {
		printf("Can't allocate space for flash sector information\n");
		return(-1);
	}
	fbnk->sectors = sinfotbl;

	/* Using the above-determined sector count, build the sector
	 * information table as part of the flash-bank structure.  For
	 * this set of devices, all sectors are the same size (0x20000).
	 */
	saddr = fbnk->base;
	for(i=0;i<fbnk->sectorcnt;i++) {
		fbnk->sectors[i].snum = snum+i;
		fbnk->sectors[i].size = 0x10000;
		fbnk->sectors[i].begin = saddr;
		fbnk->sectors[i].end =
		    fbnk->sectors[i].begin + fbnk->sectors[i].size - 1;
		fbnk->sectors[i].protected = 0;
		saddr += 0x10000;
	}
	fbnk->end = saddr-1;
	return(fbnk->sectorcnt);
}

/* FlashInit():
 * Initialize data structures for each bank of flash...
 */
int
FlashInit(void)
{
	int		snum;
	struct	flashinfo *fbnk;

	snum = 0;
	FlashCurrentBank = 0;

#ifdef FLASH_COPY_TO_RAM

	/* Copy functions to ram space... */
	/* Note that this MUST be done when cache is disabled to assure that */
	/* the RAM is occupied by the designated block of code. */

	if (flashopload((ulong *)M25p64_lock,
		(ulong *)EndM25p64_lock,
		FlashLockFbuf,sizeof(FlashLockFbuf)) < 0)
		return(-1);
	if (flashopload((ulong *)M25p64_type,
		(ulong *)EndM25p64_type,
		FlashTypeFbuf,sizeof(FlashTypeFbuf)) < 0)
		return(-1);
	if (flashopload((ulong *)M25p64_erase,
		(ulong *)EndM25p64_erase,
		FlashEraseFbuf,sizeof(FlashEraseFbuf)) < 0)
		return(-1);
	if (flashopload((ulong *)M25p64_ewrite,
		(ulong *)EndM25p64_ewrite,
		FlashEwriteFbuf,sizeof(FlashEwriteFbuf)) < 0)
		return(-1);
	if (flashopload((ulong *)M25p64_write,
		(ulong *)EndM25p64_write,
		FlashWriteFbuf,sizeof(FlashWriteFbuf)) < 0)
		return(-1);

#endif

	fbnk = &FlashBank[0];
	fbnk->base = (unsigned char *)FLASH_BANK0_BASE_ADDR;
	fbnk->width = FLASH_BANK0_WIDTH;
#ifdef FLASH_COPY_TO_RAM
	fbnk->fltype = (int(*)())FlashTypeFbuf;		/* flashtype(). */
	fbnk->flerase = (int(*)())FlashEraseFbuf;	/* flasherase(). */
	fbnk->flwrite = (int(*)())FlashWriteFbuf;	/* flashwrite(). */
	fbnk->flewrite = (int(*)())FlashEwriteFbuf;	/* flashewrite(). */
	fbnk->fllock = (int(*)())FlashLockFbuf;		/* flashelock(). */
#else
	fbnk->fltype = M25p64_type;
	fbnk->flerase = M25p64_erase;
	fbnk->flwrite = M25p64_write;
	fbnk->flewrite = M25p64_ewrite;
	fbnk->fllock = M25p64_lock;
#endif

	snum += FlashBankInit(fbnk,snum);

	sectorProtect(FLASH_PROTECT_RANGE,1);

#ifdef FLASHRAM_BASE
#ifdef FLASHRAM_SECTORSIZE
#define ramSectors 0
#endif
	FlashRamInit(snum, FLASHRAM_SECTORCOUNT,
		&FlashBank[FLASHRAM_BANKNUM], sinfoRAM, ramSectors);
#endif
	return(0);
}

#endif

#endif