flashop_intel160_.c

ADAM2 sources (modified by Oleg)

int FWBLock(bit32u from,bit32 size)
{
  return(TRUE);
}

void UnLock(bit32u adr)
{
	FWBBaseUnLockAdr=adr;
	MEM_WRITE16(adr,FLASH_LOCK_CMD);
	MEM_WRITE16(adr,FLASH_UNLOCK);
	MEM_WRITE16(adr,FLASH_READ_CMD);
}

void Lock(void)
{
	MEM_WRITE16(FWBBaseUnLockAdr,FLASH_LOCK_CMD);
	MEM_WRITE16(FWBBaseUnLockAdr,FLASH_LOCK);
    MEM_WRITE16(FWBBaseUnLockAdr,FLASH_READ_CMD);
}

int FWBGetBlockSize(bit32u base)
{
	int itmp = 0;

    base&=0x1fffffff;
    base|=0xa0000000;
  	
    if ((base>=CS0_BASE)&&(base<(CS0_BASE+CS0_SIZE)))
    {
    	itmp=(64*1024);   							/* Strata flash 8/16 bit */
	    if (base>=((CS0_BASE+CS0_SIZE)-(64*1024)))  /* Top Boot Block */
    	  itmp=(8*1024);
	    if (EMIF_ASYNC_CS0&0x2)
    	  itmp*=2;              /* Dual devices */
	    return(itmp);
    }
	return(0);
}

/* Start at base and erase at least size bytes */
int FWBErase(bit32u base,int size, int verbose)
{
	bit32u i,sts,blocksize,from,to;

	FWBopen=FALSE;

	if (size==0) 
    	return(0);
	size--;

	from=base;
	blocksize=FWBGetBlockSize(from);
	if (blocksize==0)
    {
    	sys_printf("Invalid flash address %x\n",from);
	    return(0);
    }
	from&=~(blocksize-1);

	to=base+size;
	blocksize=FWBGetBlockSize(to);
	if (blocksize==0)
    {
    	sys_printf("invalid flash address %x\n",to);
	    return(0);
    }
	to |= (blocksize-1);

	if (verbose) sys_printf("FlashEraseBlock(%08x,%08x);\n",from,to);
	for(i=from,sts=0;(i<to)&&(!sts);)
    {
    	UnLock(i);
	    MEM_WRITE16(i,FLASH_ERASE_SECTOR);
    	MEM_WRITE16(i,FLASH_COMMIT_CMD);
	    sts=_FlashOperationComplete(i,0xffff,FLASH_MAX_WAIT*5000000);
    	Lock();
	    _FlashErrorOut("Erase Block",sts);
    	
		if (verbose) sys_printf(".");
	    
		blocksize=FWBGetBlockSize(i);
    	i+=blocksize;
	    if (blocksize==0)
	   	{
			if (verbose) sys_printf("invalid flash address %x\n",i);
		      return(0);
	  	}
    }
	return(sts==0);
}

int FWBOpen(bit32u base)
{
	int i;

  	FWBopen=FALSE;
	if (FWBGetBlockSize(base)==0) 
    	return(FALSE);
  	for(i=0;i<MAXBUF;i++) 
  	  FWBwdata[i]=(char)0xff;

	FWBBaseAdr=0xffffffff;
	FWBvalid=0;
	FWBopen=TRUE;
  	return(TRUE);
}

int FWBWriteByte(bit32u adr, bit8 cVal)
{
	int sts,i;
	bit16u *isp,*idp;

   	if (!FWBopen) 
		return(FALSE);
	sts=TRUE;
 	if((adr&(~(MAXBUF-1)))!=FWBBaseAdr)
		sts=FWBClose();
	if (FWBvalid==0)
    {
    	for(i=0,isp=(bit16u *)(adr&~(MAXBUF-1)),idp=(bit16u *)FWBwdata;i<(MAXBUF/2);i++)
			*idp++=*isp++;
    }
	/*sys_printf("FWBWriteByte(%x,%x);\n",adr,cVal&0x0ff);                         */
	FWBBaseAdr=adr&(~(MAXBUF-1));
	i=adr&(MAXBUF-1);
	FWBvalid++;
	FWBwdata[i]=cVal;
	return(sts);
}

int FWBClose(void)
{
  int sts,i;

	if (!FWBopen) 
    	return(FALSE);
	if (FWBvalid==0) 
    	return(TRUE);
	
	for(i=0,sts=1;(sts)&&(i<5);i++)
    {
    	sts=_FWBWriteBlock();
	    if (sts)
		{
			MEM_WRITE16(FWBBaseAdr,FLASH_READ_CMD);
			MEM_WRITE16(FWBBaseAdr,FLASH_CLEAR_SR_CMD);
		}
	}
	_FlashErrorOut("Program Block",sts);

	for(i=0;i<MAXBUF;i++) 
    	FWBwdata[i]=(char)0xff;
	FWBBaseAdr=0xffffffff;
	FWBvalid=0;
	return(sts==0);
}

/*Used to decode Flash error values */

void _FlashErrorOut(char *str,int sts)
{
	if (sts)
		sys_printf ("Flash '%s' operation Failed: sts=%08x\n",str,sts);
}

/* Returns 0 for success and !=0 for error */

int _FWBWriteBlock(void)
{
	bit16u *uip ;
	int sts;
	
	UnLock(FWBBaseAdr);

	uip = (bit16u *)FWBwdata;	
	MEM_WRITE16(FWBBaseAdr,FLASH_WRITE_CMD);
	MEM_WRITE16(FWBBaseAdr,*uip);

	Lock();
	sts=_FlashOperationComplete(FWBBaseAdr,*uip,FLASH_MAX_WAIT*650);
	return(sts);
}

/* Returns 0 for success and !=0 for failure */

int _FlashOperationComplete(bit32u adr, bit16u dat,int timeoutloops)
{
	bit16u fnd;
	bit32u sts;
  	int icount = 0;
  	int err;

  	do
 	{
    	if (++icount>timeoutloops)
      	{
      		MEM_WRITE16(adr,FLASH_READ_CMD);    /* Reset to read mode */
      		return(0xeeee0001);
      	}
    	sts=MEM_READ16(adr);
    	if ((sts&FLASH_WSMS)==FLASH_WSMS)
      	{
			/* Check for errors */
			err = (sts&FLASH_ERROR_MASK);
			MEM_WRITE16(adr,FLASH_READ_CMD);    /* Reset to read mode */
			if (!err)
        	{
				fnd=MEM_READ16(adr);
				if (fnd==dat) 
	              return(0);	
    	    }
       		else
				MEM_WRITE16(adr,FLASH_CLEAR_SR_CMD);  /* Reset error bits */
			
        MEM_WRITE16(adr,FLASH_READ_CMD);    /* Reset to read mode */
			return(sts);
		}
    }while(1);
}