adv_ctl.c

The combined demo is dedicated for S1C33L05, so DMT33L05 should be used to load and run the demo. F

/********************************************************************************/
/*																				*/
/*	Copyright (C) SEIKO EPSON CORP. 2000										*/
/*																				*/
/*	File name : adv_ctl.c														*/
/*		This is smart media control driver										*/
/*																				*/
/*	Revision history															*/
/*		2004.05.13	David.ji support adv K9F1G16U0M								*/
/********************************************************************************/
/********************************************************************************/
/*		The tab size of this file is 4. 										*/
/********************************************************************************/

#include 	"smt.h"
#include 	"adv_ctl.h"

/********************************************************/
/*	PROTOTYPE											*/
/********************************************************/
/********************************************************/
/*	GLOBAL												*/
/********************************************************/
extern	unsigned short		ulTranBuf[];	// Transfer buffer (char -> short)

unsigned long		adv_MdaSiz;				// Media Size
struct	ADV_MEDIASIZE{
	unsigned char	bDevice[3];
	unsigned long	ulSize;
}stAdvMdaSiz[1] =	{						// Media Size Table
	  { { 0xB1, 0xC1, 0x00 },  128 },
};

static	unsigned char		adv_EraseFlg = 0;
extern	union SMT_PROLIX_BUFF	smtProlBuff;


/************************************************************************
 *  advCardDetect
 *      Type     : char
 *      Ret val  : Result Code
 *                     0 ... Not media detect
 *                     1 ... Media detect
 *      Argument : None
 *      Function : Check card detect information
 ************************************************************************/
char	advCardDetect(void)
  {
  	// always return 1
	return(1);			// Card detect signal
  }

/************************************************************************
 *  advWriteProtect
 *      Type     : char
 *      Ret val  : Result Code
 *                     0 ... Not write protect
 *                     1 ... Write protect
 *      Argument : None
 *      Function : Check write protect seal information
 ************************************************************************/
char	advWriteProtect(void)
  {
  	// alway return 0
	return(0);			// Write protect seal signal
  }


/************************************************************************
 *  advMediaReset
 *      Type     : int
 *      Ret val  : Error Code
 *                     SMT_E_SUCCESS ( 0) ... Successful
 *                     SMT_E_FAILURE (-1) ... Failure
 *      Argument : None
 *      Function : Smart media reset function
 ************************************************************************/
int	advMediaReset(void)
  {
	int iRetVal;

	ADV_R_CLE = SMT_BYTE1;			// CLE is set up in high
	ADV_R_WP = SMT_BYTE0;			// WP is set up in low
	ADV_R_ALE = SMT_BYTE0;			// ALE is set up in low

	*ADV_R_DATAIO = SMT_C_MDRESET;	// Reset command

	ADV_R_CLE = SMT_BYTE0;			// CLE is set up in low
	iRetVal = advReadyCheck(SMT_M_MS2CNT(6));

	return(iRetVal);				// Ready check (6mS) routine is call
  }

/************************************************************************
 *  advStatusRead
 *      Type     : int
 *      Ret val  : Error Code
 *                     SMT_E_SUCCESS ( 0) ... Successful
 *                     SMT_E_FAILURE (-1) ... Failure
 *      Argument : unsigned char *pStatus ... Status store buffer
 *      Function : Smart media status read
 ************************************************************************/
int	advStatusRead(unsigned char *pStatus)
  {
	int	iRetVal;								// Return Value

	iRetVal = SMT_E_SUCCESS;					// Initialize return value
	smtErrInf.iSmtErr = SMT_E_SUCCESS;			// Initialize error structure

	if(ADV_R_RB == SMT_BYTE1)
	  {
		ADV_R_CLE = SMT_BYTE1;					// CLE is set up in high
		*ADV_R_DATAIO = SMT_C_STSREAD;			// Status read command
		ADV_R_CLE = SMT_BYTE0;					// CLE is set up in low

		*(unsigned short *)pStatus = *ADV_R_DATAIO;// Read status information
	  }
	else
	  {
		smtErrInf.iSmtErr = SMT_E_STSBUSY;		// ERROR : Status busy error !!
		iRetVal = SMT_E_FAILURE;
	  }

	return(iRetVal);
  }

/************************************************************************
 *  advIdRead
 *      Type     : void
 *      Ret val  : None
 *      Argument : unsigned char *pbMaker  ... Maker code store buffer
 *                 unsigned char *pbDevice ... Device code store buffer
 *      Function : ADV media ID read command sequence
 ************************************************************************/
int	advIdRead(unsigned char *pbMaker, unsigned char *pbDevice)
  {
	long	lLoop1, lLoop2;

	if(adv_EraseFlg)
	  {
		advEraseChk();
	  }

	ADV_R_CLE = SMT_BYTE1;			// CLE is set up in high

	*ADV_R_DATAIO = SMT_C_MIDREAD;	// ID read command

	ADV_R_CLE = SMT_BYTE0;			// CLE is set up in low
	ADV_R_ALE = SMT_BYTE1;			// ALE is set up in high

	*ADV_R_DATAIO = SMT_C_DMYADDR;	// Dummy address

	ADV_R_ALE = SMT_BYTE0;			// ALE is set up in low

	asm("nop");						// Waited for 200nS

	*pbMaker = *ADV_R_DATAIO;		// Read maker code
	*pbDevice =*ADV_R_DATAIO;		// Read device code

	for(lLoop1 = 0; lLoop1 < 2; lLoop1++)
	  {
		for(lLoop2 = 0; (lLoop2 < 3)&&(stAdvMdaSiz[lLoop1].bDevice[lLoop2] != 0x00); lLoop2++)
		  {
			if(stAdvMdaSiz[lLoop1].bDevice[lLoop2] == *pbDevice)
			  {
				adv_MdaSiz = stAdvMdaSiz[lLoop1].ulSize;
				return;

			  }
		  }
	  }
  }
  
  
/************************************************************************
 *  advBlockErase
 *      Type     : int
 *      Ret val  : Error Code
 *                     SMT_E_SUCCESS ( 0) ... Successful
 *                     SMT_E_FAILURE (-1) ... Failure
 *      Argument : unsigned long ulMediaSize ... Media size information
 *                 unsigned long ulBlock     ... Physical block address
 *				   ulBlock address = virtual page address
 *      Function : Block erase command
 ************************************************************************/
int	advBlockErase(unsigned long ulBlock)
  {
	unsigned long	ulCvtPage;
	
	if(adv_EraseFlg)
	  {
		advEraseChk();
	  }
	
	ulCvtPage = ulBlock/4;

	ADV_R_WP = SMT_BYTE1;				// WP is set up in high
	ADV_R_CLE = SMT_BYTE1;				// CLE is set up in high

	*ADV_R_DATAIO = SMT_C_ERASE_1;		// Block erase command (1st)

	ADV_R_CLE = SMT_BYTE0;				// CLE is set up in low
	ADV_R_ALE = SMT_BYTE1;				// ALE is set up in high

	*ADV_R_DATAIO = (unsigned short)(ulCvtPage & 0xFF);
	*ADV_R_DATAIO = (unsigned short)((ulCvtPage >> 8) & 0xFF);

	ADV_R_CLE = SMT_BYTE1;				// CLE is set up in high
	ADV_R_ALE = SMT_BYTE0;				// ALE is set up in low

	*ADV_R_DATAIO = SMT_C_ERASE_2;		// Block erase command (2nd)

	adv_EraseFlg = 1;					// Block erasing flag set
	return(SMT_E_SUCCESS);
  }


/************************************************************************
 *  advPageRead
 *      Type     : int
 *      Ret val  : Error Code
 *                    SMT_E_SUCCESS ( 0) ... Successful
 *                    SMT_E_FAILURE (-1) ... Failure
 *      Argument : unsigned char bCommand ... Read command
 *                 unsigned long ulColumn ... Column address
 *                 unsigned long ulPage   ... Page address
 *                 char *pBuffer          ... Read data buffer
 *      Function : Page read command
 ************************************************************************/
int	advPageRead(unsigned char bCommand, unsigned long ulColumn, unsigned long ulPage, char *pBuffer)
  {
	int	iRetVal;									// Return value
	int	iLoop;										// Loop Counter
	unsigned long	uTimeLoop;						// Time Loop Counter
	unsigned long	ulCvtPage;						//

	if(adv_EraseFlg)
	  {
		advEraseChk();
	  }
	
	ulCvtPage = ulPage/4;

#ifdef	ADV_HDMA 	
	//HDMA setting
	*(volatile unsigned long*)0x48240 = 0x0;				// clear DmaReg
	*(volatile unsigned short*)0x48240 = SMT_S_DATA/2;		// transfer count
	*(volatile unsigned char*)0x48243 = 0x80;				// dual transfer mode	

	*(volatile unsigned long*)0x48244 = (unsigned long)ADV_R_DATAIO;		// source address
	*(volatile unsigned char*)0x48247 &=0xcf;								// 16bits transfer, address fixed
	*(volatile unsigned char*)0x48247 |=0x40;

	*(volatile unsigned long*)0x48248 = (unsigned long)pBuffer;			// dest address
	*(volatile unsigned char*)0x4824b &=0x7f;							// successive transfer mode, dest inc
	*(volatile unsigned char*)0x4824b |=0x70;				
#endif

	ADV_R_CLE = SMT_BYTE1;							// CLE is set up in high
	*ADV_R_DATAIO = SMT_C_DREAD_1;					// Read command
	ADV_R_CLE = SMT_BYTE0;							// CLE is set up in low
	
	ADV_R_ALE = SMT_BYTE1;							// ALE is set up in high
	*ADV_R_DATAIO = (unsigned short)(ulColumn & 0xFF);			// column address
	*ADV_R_DATAIO = (unsigned short)((ulColumn >> 8) & 0xFF);	//
	*ADV_R_DATAIO = (unsigned short)(ulCvtPage & 0xFF);			// page address
	*ADV_R_DATAIO = (unsigned short)((ulCvtPage >> 8) & 0xFF);	//
	ADV_R_ALE = SMT_BYTE0;							// ALE is set up in low
	
	ADV_R_CLE = SMT_BYTE1;							// CLE is set up in high
	*ADV_R_DATAIO = SMT_C_ADVREAD;					// Read command 30h
	ADV_R_CLE = SMT_BYTE0;							// CLE is set up in low

	iRetVal = advReadyCheck(SMT_M_US2CNT(100));		// Ready check (100uS) routine is call
	if(iRetVal == SMT_E_SUCCESS)
	 {
		if(bCommand == SMT_C_DREAD_1)				// Set read data count
		  {
			ADV_R_CLE = SMT_BYTE1;					// CLE is set up in high
			*ADV_R_DATAIO = SMT_C_RNDOUT1;			// Random Read command 05h
			ADV_R_CLE = SMT_BYTE0;					// CLE is set up in low

			ADV_R_ALE = SMT_BYTE1;					// ALE is set up in high
			*ADV_R_DATAIO = (unsigned short)(ulColumn & 0xFF);			// column address
			*ADV_R_DATAIO = (unsigned short)(((ulColumn >> 8) & 0xFF) | (ulPage % 4));
			ADV_R_ALE = SMT_BYTE0;					// ALE is set up in low

			ADV_R_CLE = SMT_BYTE1;					// CLE is set up in high
			*ADV_R_DATAIO = SMT_C_RNDOUT2;			// Random Read command e0h
			ADV_R_CLE = SMT_BYTE0;					// CLE is set up in low

#ifdef	ADV_ECC
			SMT_ECC_RST;					// Reset ECC
			SMT_ECC_EN;						// Enable ECC
#endif	//END ADV_ECC

#ifdef	ADV_HDMA
			SMT_DMA_ENABLE;
			SMT_DMA_TRG;
			
			for(uTimeLoop = 0; uTimeLoop<SMT_M_US2CNT(10); uTimeLoop++)
			{
				if(!SMT_DMA_FLAG)
					break;
			}
#else
			/* need modified while pBuffer.A0 != 0 */		
			for(iLoop = 0; iLoop < SMT_S_DATA; iLoop+=2)
			  {
				*(unsigned short*)pBuffer = *ADV_R_DATAIO;		// Read data area
				pBuffer+=2;
			  }
#endif	//END ADV_HDMA		  

#ifdef	ADV_ECC
				SMT_ECC_DIS;