nandmtd.c

原创

  if (len & 1)
    *(dst + len-1) = val;
}

/*----------------------------------------------------------------------*/
/*                      w a i t F o r R e a d y				*/
/*									*/
/* Wait for the selected device to be ready.				*/
/*                                                                      */
/* Author: 王辉              Date: 2004-8-21                            */
/*									*/
/* Parameters:                                                          */
/*	   void                                      			*/
/*									*/
/* Returns:								*/
/*	   TRUE if device is ready                          		*/
/*                                                                      */
/*----------------------------------------------------------------------*/

FLBoolean waitForReady (void)
{
    int val;
    
    do
    {
        READ_REG(val);
        val &= 0x0040;    /* R/B 接 P6.6 读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.				*/
/*                                                                      */
/* Author: 王辉              Date：2004-8-21                            */
/*                                                                      */
/* Parameters:                                                          */
/*	vol     : Pointer identifying drive			        */
/*	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);
  readCommand (cmd, address); 
  
  tffscpy16((unsigned char*)buffer, (const unsigned char *) 0x1000000, 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.    	*/
/*                                                                      */
/* Author: 王辉              Date：2004-8-21                            */
/*									*/
/* 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);
  writeCommand (cmd, address);
  
  /* load data and syndrom*/
  tffscpy16((unsigned char FAR0 *) 0x1000000, (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.					*/
/*                                                                      */
/* Author: 王辉              Date：2004-8-21                            */
/*									*/
/* 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 nandMTDRead(  FLFlash vol,
			 CardAddress address, /* target flash address */
			 void FAR1 *buffer,    /* source RAM buffer  */
			 int length,          /* bytes to write      */
			 int modes)           /* Overwrite, EDC flags etc. */
{
  char FAR1 *temp;
  int readNow;

	      /* read in sectors; first and last might be partial */

  int page = modes & EXTRA ? 16 : 512;

  readNow = page - ((unsigned short)address & (page - 1));
  temp = (char FAR1 *)buffer;
  
#ifdef DEBUG_PRINT
  DEBUG_PRINT("READ: address = 0x%x, length = 0x%x\n", address, length);
#endif
  
  for ( ; length > 0 ; )
  {
    if (readNow > length)   /* 如果要读的长度小于一个页面中偏移地址之后的空间大小 */
      readNow = length;     /* 那要读的就是该长度 04-8-6 */

    /* turn off EDC on partial block read*/   /* 如果要读的长度大于一个页面的大小，就先读一个页面 */
    checkStatus( readOnePage(&vol, address, temp, readNow,
				(readNow != SECTOR_SIZE ? (modes & ~EDC) : modes)) );

    length -= readNow;
    address += readNow;
    temp += readNow;

    /* align at sector */
    readNow = page;
  }

  return flOK ;
}


/*----------------------------------------------------------------------*/
/*		          n a n d W r i t e				*/
/*									*/
/* Write some data to the flash. This routine will be registered as the	*/
/* write routine for this MTD.						*/
/*                                                                      */
/* Author: 王辉              Date：2004-8-21                            */
/*									*/
/* 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 nandMTDWrite( FLFlash vol,
			 CardAddress address,       /* target flash address*/
			 const void FAR1 *buffer,    /* source RAM buffer  */
			 int length,                /* bytes to write      */
			 int modes)                 /* Overwrite, EDC flags etc.*/
{
  int writeNow;
  const char FAR1 *temp;
  FLStatus      status = flOK;
  
#ifdef VERIFY_AFTER_WRITE
  CardAddress  saveAddress = address;
  unsigned short flReadback[SECTOR_SIZE / sizeof(unsigned short)];
#endif 

  /* write in sectors; first and last might be partial*/
  int page = modes & EXTRA ? 16 : 512;

  writeNow = page - ((unsigned short)address & (page - 1));
  temp = (const char FAR1 *)buffer;