i28f016.c

intel xscale 425的bsp源码

/*
 * $Log:   P:/user/amir/lite/vcs/i28f016.c_v  $
 * 
 *    Rev 1.10   06 Oct 1997  9:45:48   danig
 * VPP functions under #ifdef
 * 
 *    Rev 1.9   10 Sep 1997 16:48:24   danig
 * Debug messages & got rid of generic names
 * 
 *    Rev 1.8   31 Aug 1997 15:09:20   danig
 * Registration routine return status
 * 
 *    Rev 1.7   24 Jul 1997 17:52:58   amirban
 * FAR to FAR0
 * 
 *    Rev 1.6   20 Jul 1997 17:17:06   amirban
 * No watchDogTimer
 * 
 *    Rev 1.5   07 Jul 1997 15:22:08   amirban
 * Ver 2.0
 * 
 *    Rev 1.4   04 Mar 1997 16:44:22   amirban
 * Page buffer bug fix
 * 
 *    Rev 1.3   18 Aug 1996 13:48:24   amirban
 * Comments
 * 
 *    Rev 1.2   12 Aug 1996 15:49:04   amirban
 * Added suspend/resume
 * 
 *    Rev 1.1   31 Jul 1996 14:30:50   amirban
 * Background stuff
 * 
 *    Rev 1.0   18 Jun 1996 16:34:30   amirban
 * Initial revision.
 */

/************************************************************************/
/*                                                                      */
/*		FAT-FTL Lite Software Development Kit			*/
/*		Copyright (C) M-Systems Ltd. 1995-1996			*/
/*									*/
/************************************************************************/

/*----------------------------------------------------------------------*/
/*                                                                      */
/* This MTD supports the following Flash technologies:                  */
/*                                                                      */
/* - Intel 28F016SA/28016SV/Cobra 16-mbit devices			*/
/*									*/
/* And (among else), the following Flash media and cards:		*/
/*                                                                      */
/* - Intel Series-2+ PCMCIA cards                                       */
/*									*/
/*----------------------------------------------------------------------*/
/*donleo1121 ,change for i28f320 ,the ID is by flashPtr[0] == 0x0089 && flashPtr[1] == 0x8897 */


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


/* JEDEC ids for this MTD */
#define I28F016_FLASH	0x89a0

#define SETUP_ERASE	0x2020
#define SETUP_WRITE	0x4040
#define CLEAR_STATUS	0x5050
#define READ_STATUS	0x7070
#define READ_ID 	0x9090
#define SUSPEND_ERASE	0xb0b0
#define CONFIRM_ERASE	0xd0d0
#define	RESUME_ERASE	0xd0d0
#define READ_ARRAY	0xffff

#define LOAD_PAGE_BUFFER 0xe0e0
#define WRITE_PAGE_BUFFER 0x0c0c
#define READ_EXTENDED_REGS 0x7171


#define	WSM_VPP_ERROR	0x08
#define WSM_ERROR	0x38
#define WSM_SUSPENDED	0x40
#define WSM_READY	0x80

#define GSR_ERROR	0x20


#define both(word)	(vol.interleaving == 1 ? (word) : (word) & ((word) >> 8))
#define any(word)	((word) | ((word) >> 8))

/*----------------------------------------------------------------------*/
/*                    i 2 8 f 0 1 6 W o r d S i z e			*/
/*									*/
/* Identify the card size for an Intel 28F016 word-mode Flash array.	*/
/* Sets the value of vol.noOfChips.					*/
/*									*/
/* Parameters:                                                          */
/*	vol		: Pointer identifying drive			*/
/*                                                                      */
/* Returns:                                                             */
/*	FLStatus	: 0 = OK, otherwise failed (invalid Flash array)*/
/*----------------------------------------------------------------------*/

static FLStatus i28f016WordSize(FLFlash vol)
{
  FlashWPTR flashPtr = (FlashWPTR) flMap(vol.socket,0);
  flashPtr[0] = CLEAR_STATUS;
  flashPtr[0] = READ_ID;
  /* We leave the first chip in Read ID mode, so that we can		*/
  /* discover an address wraparound.					*/

  for (vol.noOfChips = 1;	/* Scan the chips */
       vol.noOfChips < 2000;  /* Big enough ? */
       vol.noOfChips++) {
    flashPtr = (FlashWPTR) flMap(vol.socket,vol.noOfChips * vol.chipSize);

    if (flashPtr[0] == 0x0089 && flashPtr[1] == 0x8897)
      break;	  /* We've wrapped around to the first chip ! */

    flashPtr[0] = READ_ID;
    if (!(flashPtr[0] == 0x0089 && flashPtr[1] == 0x8897))
      break;
    flashPtr[0] = CLEAR_STATUS;
    flashPtr[0] = READ_ARRAY;
  }

  flashPtr = (FlashWPTR) flMap(vol.socket,0);
  flashPtr[0] = READ_ARRAY;

  return flOK;
}


/*----------------------------------------------------------------------*/
/*                      i 2 8 f 0 1 6 W r i t e				*/
/*									*/
/* Write a block of bytes to Flash					*/
/*									*/
/* This routine will be registered as the MTD flash.write routine	*/
/*									*/
/* Parameters:                                                          */
/*	vol		: Pointer identifying drive			*/
/*      address		: Card address to write to			*/
/*      buffer		: Address of data to write			*/
/*	length		: Number of bytes to write			*/
/*	overwrite	: TRUE if overwriting old Flash contents	*/
/*			  FALSE if old contents are known to be erased	*/
/*                                                                      */
/* Returns:                                                             */
/*	FLStatus	: 0 on success, failed otherwise		*/
/*----------------------------------------------------------------------*/

static FLStatus i28f016Write(FLFlash vol,
			   CardAddress address,
			   const void FAR1 *buffer,
			   int length,
			   FLBoolean overwrite)
{
  /* Set timeout ot 5 seconds from now */
  unsigned long writeTimeout = flMsecCounter + 5000;


/*donleo1121, add for WORD 16bit*/
	int iInterleaving;
/**/
  FLStatus status;
  int i, cLength;
  FlashPTR flashPtr;
FlashWPTR	wordFlashPtr;	/*donleo for 16 bit*/

	sysFlashWriteEnable();	/*donleo1121,enable */
  if (flWriteProtected(vol.socket)) {
	sysFlashWriteDisable();
	return flWriteProtect;
	}

  flashPtr = (FlashPTR) vol.map(&vol, address,length);
  cLength = length;
/*donleo1121 store the value*/
	iInterleaving=vol.interleaving;
/**/
  vol.interleaving = 2; /*donleo1121,for 16 bit ,will be faster*/
  if (vol.interleaving == 1) {
lastByte:
#ifdef __cplusplus
    #define bFlashPtr  flashPtr
  	#define bBuffer ((const unsigned char FAR1 * &) buffer) 
#else
    #define bFlashPtr  flashPtr
    #define bBuffer ((const unsigned char FAR1 *) buffer)
#endif
    while (cLength >= 1) {
      *bFlashPtr = (UINT8)SETUP_WRITE;
      *bFlashPtr = *bBuffer;
		do
		    {
		    *bFlashPtr = (UINT8)READ_STATUS;
		    }
		while ((*bFlashPtr & WSM_READY) != (unsigned char)WSM_READY);

      cLength--;
      bBuffer++;
      bFlashPtr++;
      while (!(bFlashPtr[-1] & WSM_READY) && flMsecCounter < writeTimeout)
	;
    }
  }
   else if (vol.interleaving == 2) {
lastWord:
#ifdef __cplusplus
    #define wFlashPtr ((FlashWPTR &) flashPtr)
    #define wBuffer ((const unsigned short FAR1 * &) buffer)
#else
    #define wFlashPtr ((FlashWPTR) flashPtr)
    #define wBuffer ((const unsigned short FAR1 *) buffer)
#endif
    while (cLength >= 2) {
      *wFlashPtr = SETUP_WRITE;        flDelayLoop(2);  /* HOOK for VME-177 */
      *wFlashPtr = *wBuffer;                   flDelayLoop(2);  /* HOOK for VME-177 */
		do
		    {
		    *wFlashPtr = READ_STATUS;
		    }
		while ((*wFlashPtr & WSM_READY) != (unsigned short)WSM_READY);

      cLength -= 2;
      wBuffer++;
      wFlashPtr++;
      while (!(wFlashPtr[-1] & (WSM_READY)) && flMsecCounter < writeTimeout)
	;
    }
    if (cLength > 0)
      goto lastByte;
  }
  else /* if (vol.interleaving >= 4) */ {
#ifdef __cplusplus
    #define dFlashPtr ((FlashDPTR &) flashPtr)
    #define dBuffer ((const unsigned long FAR1 * &) buffer)
#else
    #define dFlashPtr ((FlashDPTR) flashPtr)
    #define dBuffer ((const unsigned long FAR1 *) buffer)
#endif
    while (cLength >= 4) {
      *dFlashPtr = SETUP_WRITE;    flDelayLoop(2);  /* HOOK for VME-177 */
      *dFlashPtr = *dBuffer;                    flDelayLoop(2);  /* HOOK for VME-177 */

		do
		    {
		    *dFlashPtr = READ_STATUS;
		    }
		while ((*dFlashPtr & WSM_READY) != (unsigned int)WSM_READY);
		/* Check Byte Write Error Status */
      cLength -= 4;