k9f2808u0c.c

Vxworks下BSP源码

#include "tffs/flflash.h"
#include "tffs/reedsol.h"

/*PIO pins & reg used*/
#define AT91C_PIO_PC1      		 		 ((unsigned int) 1 << 1)  /* Pin Controlled by PC1  */
#define AT91C_PC1_BFRDY_SMOE	 		((unsigned int) AT91C_PIO_PC1) /*  SmartMedia Output Enable */
#define AT91C_PIO_PC3        				((unsigned int) 1 << 3)  /* Pin Controlled by PC13 */
#define AT91C_PC3_BFBAA_SMWE 			((unsigned int) AT91C_PIO_PC3) /*  SmartMedia Write Enable */
#define AT91C_PIO_PC14       				((unsigned int) 1 << 14) /* Pin Controlled by PC14 */
#define AT91C_PIO_PC15      				 ((unsigned int) 1 << 15) /* Pin Controlled by PC15 */

/* registers */
#define AT91C_EBI_CSA   					0xFFFFFF60 /* (EBI) Chip Select Assignment Register */
#define AT91C_SMC_CSR3					0xFFFFFF7C		/*CS3 for nand flash*/	
#define AT91C_SMC_CSR4					0xFFFFFF80		/*CS4 for nand flash*/	

#define AT91C_PIOC_PER       			 	0xFFFFF800 /* (PIOC) PIO Enable Register */
#define AT91C_PIOC_PDR  			 	0xFFFFF804 /* (PIOC) PIO Disable Register */
#define AT91C_PIOC_OER        				0xFFFFF810 /* (PIOC) Output Enable Register */
#define AT91C_PIOC_ODR     			   	0xFFFFF814 /* (PIOC) Output Disable Register */
#define AT91C_PIOC_SODR       			0xFFFFF830 /* (PIOC) Set Output Data Register */
#define AT91C_PIOC_CODR        			0xFFFFF834 /* (PIOC) Clear Output Data Register */
#define AT91C_PIOC_PDSR			 	0xFFFFF83C /* (PIOC) Pin Data Status Register */
#define AT91C_PIOC_ASR  			 	0xFFFFF870 /* (PIOC) Select A Register */

#define NAND_EN()	 					(*(volatile UINT32 *)AT91C_PIOC_CODR = AT91C_PIO_PC15)				
#define NAND_DIS()						(*(volatile UINT32 *)AT91C_PIOC_SODR = AT91C_PIO_PC15)
#define READ_REG(val)       				((int)(val) = (*(volatile UINT32 *)AT91C_PIOC_PDSR) & AT91C_PIO_PC14)

#define WRITE_COMMAND(val) 			 (*(volatile char *)0x50000080 = (char)(val)) /* CLE = A7 */
#define WRITE_ADDRESS(val)  				(*(volatile char *)0x50000040 = (char)(val)) /* ALE = A6 */
#define WRITE_DATA(val)     				(*(volatile char *)0x50000000 = (char)(val)) /*  CE = 0 CLE = 0 ALE = 0  */
#define READ_DATA(val)      				((char)(val) = *(volatile char *)0x50000000) /*  CE = 0 CLE = 0 ALE = 0  */


#define PAGES_PER_BLOCK    		 32          /* 32 pages per block on a single chip*/

/* Flash ID*/
#define K9F2808U0C_FLASH		0xEC73


/* Flash commands:*/
#define SERIAL_DATA_INPUT  		0x80
#define READ_MODE          			0x00
#define READ_MODE_2      			0x50
#define RESET_FLASH       			0xff
#define SETUP_WRITE         		0x10
#define SETUP_ERASE         		0x60
#define CONFIRM_ERASE       		0xd0
#define READ_STATUS         		0x70
#define READ_ID             			0x90

#define FAIL                0x01
#define RB                  0x40


/*for debug*/
#undef DEBUG_PRINT         printf

/* commands for moving flash pointer to areeas A,B or C of page*/
typedef enum  { AREA_A = READ_MODE, AREA_B = 0x1, AREA_C = READ_MODE_2 } PointerOp;

/* customization for this MTD*/

typedef struct {
  unsigned short	vendorID;
  unsigned short	chipID;
  unsigned short      	pageSize ;              /* all....................*/
  unsigned short      	pageMask ;              /* ...these...............*/
  unsigned short      	pageAreaSize ;          /* .......variables.......*/
  unsigned short      	tailSize ;              /* .............interleave*/
  unsigned short      	noOfBlocks ;            /* total erasable blocks in flash device*/
  FLBuffer  		*buffer;		/* buffer for map through buffer */
} Vars;

static Vars mtdVars[DRIVES];

#define thisVars   ((Vars *) vol.mtdVars)
#define thisBuffer (thisVars->buffer->data)



/*添加*/

UINT8 mapBuffer1[600];
UINT8 mapBuffer2[600];
UINT8 mapBuffer3[600];
UINT8 bufferPtr=0;
UINT8 *ptr;



/*---------------------------------------------------------------------- 
*              flashInit                                        
*									 
*	initalize PIOC pins & SmartMedia Logic.
*                                                              
*----------------------------------------------------------------------*/
void flashInit()
{	
	*(volatile UINT32 *)AT91C_EBI_CSA |= (1<<3);  /*SmartMedia Logic*/ 	
	*(volatile UINT32 *)AT91C_SMC_CSR4 = 0x22004787; /*CS4*/
	
	*(volatile UINT32 *)AT91C_PIOC_PDR = AT91C_PIO_PC1 | AT91C_PIO_PC3;
	*(volatile UINT32 *)AT91C_PIOC_ASR = AT91C_PC1_BFRDY_SMOE | AT91C_PC3_BFBAA_SMWE;
	
	/* PC14 used for R/#B--input, PC15 used for #CE--output*/
	*(volatile UINT32 *)AT91C_PIOC_PER = AT91C_PIO_PC14 | AT91C_PIO_PC15;
	*(volatile UINT32 *)AT91C_PIOC_OER = AT91C_PIO_PC15;
	*(volatile UINT32 *)AT91C_PIOC_ODR = AT91C_PIO_PC14;
}

#if 0
/*---------------------------------------------------------------------- 
*              t f f s c p y 1 6                                        
*									 
* Move data in 16-bit words.                                            
*                                                                       
* Parameters:                                                           
*      dst             : destination buffer                             
*      src             : source buffer                                  
*      len             : bytes to move                                  
*                                                                       
*----------------------------------------------------------------------*/

static void tffscpy16 (unsigned char FAR0       *dst,
		       const unsigned char FAR0 *src,
		       int                      len)
{
  register int i = 0;

  /* move data in 16-bit words */
  for (i = 0;  i < (len >> 1);  i++)
    *((unsigned short *) dst + i) = *((unsigned short *) src + i);

  /* move last byte (if any) */
  if (len & 1)
    *(dst + len-1) = *(src + len-1);
}



/*---------------------------------------------------------------------- 
*              t f f s s e t 1 6                                        
*									 
* Set data buffer in 16-bit words.                                      
*                                                                       
* Parameters:                                                           
*      dst             : destination buffer                             
*      val             : byte value tofill the buffer                   
*      len             : setination buffer size in bytes                
*                                                                       
*----------------------------------------------------------------------*/

static void tffsset16 (unsigned char FAR0 *dst,
		       unsigned char      val,
		       int                len)
{
  register unsigned short  wval = ((unsigned short)val << 8) | val;
  register int   i = 0;

  /* set data in 16-bit words */
  for (i = 0;  i < (len >> 1);  i++)
    *((unsigned short *) dst + i) = wval;

  /* set last byte (if any) */
  if (len & 1)
    *(dst + len-1) = val;
}


#endif
/*---------------------------------------------------------------------- 
*                      w a i t F o r R e a d y				 
*									 
* Wait for the selected device to be ready.				 
*                                                                       
*									 
* Parameters:                                                           
*	   void                                      			 
*									 
* Returns:								 
*	   TRUE if device is ready                          		 
*                                                                       
*----------------------------------------------------------------------*/

FLBoolean waitForReady (void)
{
    int val;
    
    do
    {
        READ_REG(val); /* R/#B 接PC14，读R/B状态判断设备状态 */ 
    } while(val == 0);
    return TRUE; 
}

/*---------------------------------------------------------------------- 
*		          m a k e C o m m a n d				 
*									 
* Set Page Pointer to Area A, B or C in page.				 
*                                                                       
*                                                                       
* Parameters:                                                           
*	cmd	: receives command relevant to area			 
*	addr	: receives the address to the right area.		 
*	modes	: mode of operation (EXTRA ...)				 
*                                                                       
*----------------------------------------------------------------------*/

static void makeCommand (PointerOp *cmd, CardAddress address, int modes)
{
    int bit8;

    if (modes & EXTRA)
      *cmd = AREA_C;
    else
      { 
      	bit8 = (unsigned short)address & 0x100;
      	if(bit8 == 0)
      	  *cmd = AREA_A;
      	else
      	  *cmd = AREA_B;
      }
}


/*---------------------------------------------------------------------- 
*		          s e t A d d r e s s				 
*									 
* Latch address to selected flash device.				 
*									 
* Parameters:                                                           
*	address		: address to set.				 
*                                                                       
*----------------------------------------------------------------------*/

static void setAddress(CardAddress address )
{
  WRITE_ADDRESS((unsigned char)address);
  WRITE_ADDRESS((unsigned char)(address >> 9));
  WRITE_ADDRESS((unsigned char)(address >> 17));
}


/*---------------------------------------------------------------------- 
*		          r e a d C o m m a n d				 
*									 
* Issue read command.							 
*									 
* Parametes:                                                          	 
*      cmd		: Command to issue (according to area). 	 
*	address		: address to read from.				 
*									 
*----------------------------------------------------------------------*/

static void readCommand (PointerOp  cmd, CardAddress address)
{
  WRITE_COMMAND (cmd);       /* move flash pointer to respective area of the page*/
  setAddress (address);
  waitForReady();
}


/*---------------------------------------------------------------------- 
*		          w r i t e C o m m a n d			 
*									 
* Issue write command.							 
*									 
* Parametes:                                                          	 
*      cmd		: Command to issue (according to area). 	 
*	address		: address to write to.				 
*									 
*----------------------------------------------------------------------*/

static void writeCommand (PointerOp  cmd, CardAddress address)
{
  WRITE_COMMAND(cmd);       /* move flash pointer to respective area of the page  */  
	WRITE_COMMAND(SERIAL_DATA_INPUT);       /* start data loading for write  */
  setAddress (address);
}


/*---------------------------------------------------------------------- 
*		          r e a d S t a t u s				 
*									 
* Read status of selected flash device.				 
*									 
* Parameters:								 
*									 
* Returns:                                                          	 
*      Chip status.							 
*									 
*----------------------------------------------------------------------*/

unsigned char readStatus(void)
{
  unsigned char chipStatus ;

  WRITE_COMMAND(READ_STATUS);
  READ_DATA(chipStatus);
 
  return chipStatus;
}


/*---------------------------------------------------------------------- 
*		          w r i t e E x e c u t e			 
*									 
* Execute write.							 
*									 
* Parametes:								 
* Returns:                                                          	 
*	FLStatus	: 0 on success, otherwise failed.		 
*									 
*----------------------------------------------------------------------*/

static FLStatus writeExecute (void)
{
  WRITE_COMMAND(SETUP_WRITE);             /* execute page program*/
  waitForReady();

  if(readStatus() & FAIL)
    return flWriteFault ;

  return flOK ;
}



/*---------------------------------------------------------------------- 
*		          r e a d O n e S e c t o r			 
*									 
* Read up to one 512-byte block from flash.				 
*									 
* Parameters:								 
*	vol		: Pointer identifying drive			 
* 	address	: Address to read from.					 
*	buffer	: buffer to read to.					 
*	length	: number of bytes to read (up to sector size).		 
*	modes	: EDC flag etc.						 
*									 
* Returns:                                                          	 
*	FLStatus: 0 on success, otherwise failed.			 
*									 
*----------------------------------------------------------------------*/

static FLStatus readOnePage (FLFlash vol,
			     CardAddress address,  /* starting flash address*/
			     char FAR1 *buffer,     /* target buffer */
			     int length,           /* bytes to read */
			     int modes)            /* EDC flag etc.*/
{
  FLStatus  status = flOK;
  PointerOp   cmd;

  int bit8;

  /* move flash pointer to areas A,B or C of page*/

  makeCommand (&cmd, address, modes);
  NAND_EN();	
  readCommand (cmd, address); 

  while(length-->0)
  {
	READ_DATA(*(buffer++));
  }
  
  /*tffscpy16((unsigned char*)buffer, (const unsigned char *) 0x40000000, length );*/

  return status;
}



/*---------------------------------------------------------------------- 
*		          w r i t e O n e S e c t o r			 
*									 
* Write data in one 512-byte block to flash.				 
* Assuming that EDC mode never requested on partial block writes.    	 
*                                                                  									 
* Parameters:								 
*	vol	: Pointer identifying drive			 
* 	address	: Address of sector to write to.			 
*	buffer	: buffer to write from.					 
*	length	: number of bytes to write (up to sector size).		 
*	modes	: OVERWRITE, EDC flags etc.				 
*									 
* Returns:                                                          	 
*	FLStatus: 0 on success, otherwise failed.			 
*									 
*----------------------------------------------------------------------*/

static FLStatus writeOnePage(FLFlash vol,
			     CardAddress address,    /* target flash addres  */
			     const char FAR1 *buffer, /* source RAM buffer   */
			     int length,             /* bytes to write (up to BLOCK) */
			     int modes)              /* OVERWRITE, EDC flags etc.  */
{
  FLStatus    status;
  PointerOp cmd;
  int bit8;
  
  if (flWriteProtected(vol.socket))
    return flWriteProtect;

  /* move flash pointer to areas A,B or C of page  */

  makeCommand (&cmd, address, modes);
  NAND_EN();
  writeCommand (cmd, address);
  
  /* load data and syndrom*/
  while(length-->0)
  {
	WRITE_DATA(*(buffer++));

  }
 /* tffscpy16((unsigned char FAR0 *) 0x40000000, (const unsigned char *)buffer, length ); */
  status = writeExecute();
  
#ifdef DEBUG_PRINT
  DEBUG_PRINT("WRITE: address = 0x%x, length = 0x%x, mode = %d\n", address, length, modes);
#endif

  return status;
}


    /* Core MTD methods - read, write and erase */ 

/*---------------------------------------------------------------------- 
*		          n a n d  R e a d				 
*									 
* Read some data from the flash. This routine will be registered as 	 
* the read routine for this MTD.
*									 
* Parameters:								 
*	vol		: Pointer identifying drive			 
* address	: Address to read from.					 
*	buffer	: buffer to read to.					 
*	length	: number of bytes to read (up to sector size).