spistatus.c

GM5621原代码

	BYTE B_Ctrl, B_CtrlPB, B_CtrlPBCS;

  // wait for current transaction to complete (up to 3 words could still be transfered to cache
   while ( gm_ReadRegByte(SPI_STATUS) & SPI_BUSY);
   gm_WriteRegByte(SPI_CACHE_CTRL , 0);  // disable cache
   gm_ClearRegBitsByte(SPI_CONTROL, FLASH_CHIP_SEL);
	B_Ctrl = gm_ReadRegByte(SPI_CONTROL);	// B_Ctrl - Data mode, WORD exchange operation
   gm_WriteRegByte(SPI_CONTROL, B_Ctrl | SPI_PROGRAM_EN);
   // force at least 70ns delay before continuing SPI setup
   asm nop;
   asm nop;
   asm nop;
   asm nop;
   asm nop;
   asm nop;
   asm nop;
   asm nop;
	B_CtrlPB = (B_Ctrl | SPI_PROGRAM_EN | SPI_BYTE_EX);				// B_CtrlPB - Program mode, BYTE exchange operation
	gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);

	B_CtrlPBCS = (B_CtrlPB | FLASH_CHIP_SEL); // B_CtrlPBCS - FLASH_CHIP_SELECT = 1

   if(B_mode==REG_READ_MODE)
   {
	   //read status register
   	v = ReadStatusReg(B_CtrlPBCS, B_CtrlPB);
   }
   else if(B_mode==REG_CONFIG_READ_MODE)
   {
	   //read status register
   	v = ReadConfigStatusReg(B_CtrlPBCS, B_CtrlPB);
   }
	else if(B_mode==REG_PROTECT_MODE || B_mode==REG_UNPROTECT_MODE)
   {
   	cmd = ((B_mode==REG_PROTECT_MODE)?CMD_SET_BPX:CMD_CLEAR_BPX);

      // Send write enable (WREN) command
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);	// enable device
      SPI_WriteByte(CMD_WRITE_ENABLE);			// send WREN command
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);	// disable device
      if(B_FlashChipID==SST25VF010_ID)
      {
      	gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);		// enable device
         SPI_WriteByte(CMD_WRITE_DISABLE);				// send WRDI command
         gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);		// disable device
         // Send Enable Write Status command
         gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);		// enable device
         SPI_WriteByte(CMD_ENABLE_WRITE_SR);				// enable writing to the status register
         gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);		// disable device
      }

      // Send command to clear write protect bits in SR
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);		// enable device
      SPI_WriteByte(CMD_WRITE_TO_SR);		// select write to status register
      SPI_WriteByte(cmd);						// data that will change the status of BPx or BPL (only bits 2,3,7 can be written)
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);		// disable the device

      Wait_Busy(B_CtrlPBCS, B_CtrlPB);				// Wait for the write protect bits to clear

	   //read status register
   	v = ReadStatusReg(B_CtrlPBCS, B_CtrlPB);
   }
   else if(B_mode==REG_CONFIG_PROTECT_MODE || B_mode==REG_CONFIG_UNPROTECT_MODE)
   {
   	cmd = B_data;

      // Send write enable (WREN) command
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);	// enable device
      SPI_WriteByte(CMD_WRITE_ENABLE);			// send WREN command
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);	// disable device
#if 0 //SST does NOT support these commands
      if(B_FlashChipID==SST25VF010_ID)
      {
      	gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);		// enable device
         SPI_WriteByte(CMD_WRITE_DISABLE);				// send WRDI command
         gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);		// disable device
         // Send Enable Write Status command
         gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);		// enable device
         SPI_WriteByte(CMD_ENABLE_WRITE_SR);				// enable writing to the status register
         gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);		// disable device
      }
#endif
      // Send command to clear write protect bits in SR
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);		// enable device
      SPI_WriteByte(CMD_WRITE_WRCR);		// select write to configuration register
      SPI_WriteByte(cmd);						// data that will change the status of SCFG bit0 and SPn bitn
      gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);		// disable the device

      Wait_Busy(B_CtrlPBCS, B_CtrlPB);				// Wait for the write protect bits to clear

	   //read status register
   	v = ReadConfigStatusReg(B_CtrlPBCS, B_CtrlPB);
   }

   //restore
	gm_WriteRegByte(SPI_CONTROL, B_Ctrl);


	return  v;
}

//***************************************************************
// FUNCTION     :   void SPI_WriteByte(BYTE B_Value)
// USAGE        :
// DESCRIPTION  :   This procedure outputs a byte
// INPUT        :   BYTE B_Value - byte for write to the register
// OUTPUT       :   None
//***************************************************************
static __near void SPI_WriteByte(BYTE B_Value)
{
	gm_WriteRegByte(SPI_DATA_1,B_Value);

	WAIT_EX_DONE();
}

//***************************************************************
// FUNCTION     :   BYTE SPI_ReadByte(void)
// USAGE        :
// DESCRIPTION  :   This procedure inputs a byte
// INPUT        :   None
// OUTPUT       :   BYTE
//***************************************************************
static __near BYTE SPI_ReadByte(void)
{
	gm_WriteRegByte(SPI_DATA_1,0x00);
    WAIT_EX_DONE();
	return gm_ReadRegByte(SPI_DATA_0);
}

//***************************************************************
// FUNCTION     :   timeoutCheck
// DESCRIPTION  :   perfom timeout check.  Function looks at Timer2
//                  Max Count bit (rollover bit), each time it's set
//                  1ms. has gone by.  Each time it's set decrement
//                  *timeout until it reaches zero.
// INPUT        :   timeout
// OUTPUT       :   Pass/Fail
//***************************************************************
static __near BYTE timeoutCheck(WORD *timeout)
{
	// Watch timer2 rollover bit (MC) each time it rolls over 1ms has gone
	// by.
	if(READ_PCB_REG(T2CON) & MC)
	{// clear Max Count (rollover) bit.
		CLEAR_PCB_REG_BITS(T2CON, MC);
		if(*timeout)
			(*timeout)--;
		else
			return gmd_TRUE;
	}
	return gmd_FALSE;
}

//***************************************************************
// FUNCTION     :   BYTE SPI_ReadStatusReg(void)
// USAGE        :
// DESCRIPTION  :   This procedure read the status register and returns the byte
// INPUT        :   None
// OUTPUT       :   BYTE Status
//***************************************************************
static __near BYTE ReadStatusReg(BYTE B_CtrlPBCS, BYTE B_CtrlPB)
{
	BYTE B_Stat;

	gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);
	SPI_WriteByte(CMD_READ_SR);
	B_Stat = SPI_ReadByte();
	gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);
	return B_Stat;
}

//***************************************************************
// FUNCTION     :   BYTE SPI_ReadStatusReg(void)
// USAGE        :
// DESCRIPTION  :   This procedure read the status register and returns the byte
// INPUT        :   None
// OUTPUT       :   BYTE Status
//***************************************************************
static __near BYTE ReadConfigStatusReg(BYTE B_CtrlPBCS, BYTE B_CtrlPB)
{
	BYTE B_Stat;

	gm_WriteRegByte(SPI_CONTROL, B_CtrlPBCS);
	SPI_WriteByte(CMD_READ_RDCR);
	B_Stat = SPI_ReadByte();
	gm_WriteRegByte(SPI_CONTROL, B_CtrlPB);
	return B_Stat;
}


//***************************************************************
// FUNCTION     :   BYTE Wait_Busy(void)
// USAGE        :
// DESCRIPTION  :   This procedure waits until device is no longer busy (can be used by
//					Byte-Program, Sector-Erase, Block-Erase, Chip-Erase).
// INPUT        :   None
// OUTPUT       :   0 - OK, 1 - Error (Timeout)
//***************************************************************
static __near BYTE Wait_Busy(BYTE B_CtrlPBCS, BYTE B_CtrlPB)
{
	WORD W_Timeout = FLASH_TIMEOUT;


	while ((ReadStatusReg(B_CtrlPBCS, B_CtrlPB) & CHIP_STATUS_BUSY))	/* waste time until not busy */
	{
		if(timeoutCheck(&W_Timeout))
		{
			return ERROR_TIMEOUT;
		}
	}
	return 0;
}

void DummyReadFlashStatusRegister()
{
}


#endif