flashop_intel640_.c

ADAM2 sources (modified by Oleg)

  to=from+size;
  blocksize=FWBGetBlockSize(from);
  from&=~(blocksize-1);
  for(sts=0,ad=from;(ad<to)&&(!sts)&&(blocksize);ad+=blocksize)
    {
    uip=(bit32u *)ad;
    uitmp=*uip;
    MEM_WRITE(ad,0x00600060);
    MEM_WRITE(ad,0x00010001);
    sts&=_FlashOperationComplete(ad,uitmp,650*FLASH_MAX_WAIT);
    _FlashErrorOut("Lock Block",sts);
    blocksize=FWBGetBlockSize(ad);
    }
  return(sts==0);
  }

int FWBGetBlockSize(bit32u base)
  {
  int itmp;

  base&=0x1fffffff;
  base|=0xa0000000;
#ifdef _AVALANCHE_    /*EVM*/
  if ((base>=CS3_BASE)&&(base<(CS3_BASE+CS3_SIZE)))
    {
    itmp=(128*1024);   /*Strata flash 8/16 bit*/
    if (EMIF_ASYNC_CS3&0x2)
      itmp*=2;              /*Dual devices*/
    return(itmp);
    }
#endif
  if ((base>=CS0_BASE)&&(base<(CS0_BASE+CS0_SIZE)))
    {
    itmp=(128*1024);   /*Strata flash 8/16 bit*/
    if (EMIF_ASYNC_CS0&0x2)
      itmp*=2;              /*Dual devices*/
    return(itmp);
    }
  return(0);
  }

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);)
    {
    MEM_WRITE(i,0x00200020);
    MEM_WRITE(i,0x00d000d0);
    sts=_FlashOperationComplete(i,0xffffffff,FLASH_MAX_WAIT*5000000);
    _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<64;i++) 
    FWBwdata[i]=0xff;
  FWBBaseAdr=0xffffffff;
  FWBvalid=0;
  FWBopen=TRUE;
  return(TRUE);
  }

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

  if (!FWBopen) 
    return(FALSE);
  sts=TRUE;
  if((adr&(~0x3f))!=FWBBaseAdr)
    sts=FWBClose();
  if (FWBvalid==0)
    {
    for(i=0,isp=(bit32u *)(adr&~0x3f),idp=(bit32u *)FWBwdata;i<16;i++)
      *idp++=*isp++;
    }
  /*sys_printf("FWBWriteByte(%x,%x);\n",adr,cVal&0x0ff); */
  FWBBaseAdr=adr&(~0x3f);
  i=adr&0x3f;
  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_WRITE(FWBBaseAdr,0x00ff00ff);
      MEM_WRITE(FWBBaseAdr,0x00500050);
      }
    }

  _FlashErrorOut("Program Block",sts);

  for(i=0;i<64;i++) 
    FWBwdata[i]=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)
  {
  int icount,i,done;
  bit32u *uip,uitmp;

  MEM_WRITE(FWBBaseAdr,0x00e800e8);
  icount=0;
  do
    {
    uitmp=MEM_READ(FWBBaseAdr);
    done = ((uitmp&0x00800080)==0x00800080);
    if ((!done)&&(icount>(FLASH_MAX_WAIT*650)))
      return(0xeeee0002);
    icount++;
    }while(!done);
  MEM_WRITE(FWBBaseAdr,0x000f000f);
  for(uip=(bit32u *)FWBwdata,i=0;i<16;i++,uip++)
    MEM_WRITE(FWBBaseAdr+(i*4),*uip);
  MEM_WRITE(FWBBaseAdr,0x00d000d0);
  uip=(bit32u *)FWBwdata;
  return(_FlashOperationComplete(FWBBaseAdr,*uip,FLASH_MAX_WAIT*650));
  }

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

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

  icount=0;
  do
    {
    if (++icount>timeoutloops)
      {
      MEM_WRITE(adr,0x00ff00ff);    /*Reset to read mode */
      return(0xeeee0001);
      }
    sts=MEM_READ(adr);
    if ((sts&0x00800080)==0x00800080)
      {
      err = (sts&0x00300030);
      MEM_WRITE(adr,0x00ff00ff);    /*Reset to read mode */
      if (!err)
        {
        fnd=MEM_READ(adr);
        if (fnd==dat) 
          return(0);
        }
       else
        MEM_WRITE(adr,0x00500050);  /*Reset error bits */
      return(sts);
      }
    }while(1);
  }