fdi_spll.c

FDI Intel开发的FLASH文件系统,功能很强大

/* Copyright(R) 2001 Intel Corporation */
/* ############################################################################
 ### Object: Low Level Driver
 ###
 ### Module: FDI_Spll.c - Single Partition Low-Level
 ###   $Archive: /FDI/SRC/LOWLVL/fdi_spll.c $
 ###   $Revision: 38 $
 ###   $Date: 10/14/04 2:08p $
 ###   $Author: Wtiso $
 ###
 ###$NoKeywords: $
 ########################################################################### */

/*                                                               
 *****************************************************************
 * NOTICE OF LICENSE AGREEMENT                                    
 *                                                                
 * This code is provided by Intel Corp., and the use is governed  
 * under the terms of a license agreement. See license agreement  
 * for complete terms of license.                                 
 *                                                                
 * YOU MAY ONLY USE THE SOFTWARE WITH INTEL FLASH PRODUCTS.  YOUR 
 * USE OF THE SOFTWARE WITH ANY OTHER FLASH PRODUCTS IS EXPRESSLY 
 * PROHIBITED UNLESS AND UNTIL YOU APPLY FOR, AND ARE GRANTED IN  
 * INTEL'S SOLE DISCRETION, A SEPARATE WRITTEN SOFTWARE LICENSE   
 * FROM INTEL LICENSING ANY SUCH USE.                             
 *****************************************************************
 */
 

#ifdef CURRENT_FILE_BEING_COMPILED
#undef CURRENT_FILE_BEING_COMPILED
#endif

#define CURRENT_FILE_BEING_COMPILED FDI_SPLL


/*
 *### Include Files
 *#########################
 */

#include "fdi_lowl.h"

#if (PARTITIONS == SINGLE)
#include "fdi_int.h"

#ifdef CUSTOM_SEM_MTX
#include "fdi_mutx.h"
#endif

#if (PACKET_DATA == TRUE)
#include "fdi_pckt.h"
#endif



/*
 *### Local Declarations
 *#########################
 */

/* Absolute physical starting address of flash */
#define LOWLVL_FLASH_START_ADDRESS           FLASH_START_ADDRESS

#if (ADDRESS_VALIDATION == TRUE)
/* The start and end addresses of the data-managed area within flash */
#define LOWLVL_DATA_START_ADDRESS            FDV_START_ADDRESS
#define LOWLVL_DATA_END_ADDRESS \
   (FDV_START_ADDRESS + (FDV_BLOCKCOUNT * FDV_BLOCK_SIZE) - 1)

/* The start and end addresses of the code-managed area within flash */
#if (DIRECT_ACCESS_VOLUME == TRUE)
#define LOWLVL_CODE_START_ADDRESS            DAV_START_ADDRESS
#define LOWLVL_CODE_END_ADDRESS \
   (DAV_START_ADDRESS + (DAV_BLOCKCOUNT * DAV_BLOCK_SIZE) - 1)
#endif /* DIRECT_ACCESS_VOLUME */
#endif /* ADDRESS_VALIDATION */

/* A flash data value with all its bits set */
#define ALL_F                          ((FLASH_DATA) (-1))


/*
 * Validates that the address and length of the buffer lie entirely within
 * the data managed blocks (or code managed blocks if DAV is enabled).
 */
#if (ADDRESS_VALIDATION == TRUE)
#if (DIRECT_ACCESS_VOLUME != TRUE)
#define VALIDATE_ADDRESS(addr, len) \
   if (((addr) < LOWLVL_DATA_START_ADDRESS) || \
      (((addr) + (len) - 1) > LOWLVL_DATA_END_ADDRESS)) \
   { \
      return HW_ERR_PARAM; \
   }
#else /* DIRECT_ACCESS_VOLUME == TRUE */
#define VALIDATE_ADDRESS(addr, len) \
   if ((((addr) < LOWLVL_DATA_START_ADDRESS) || \
      (((addr) + (len) - 1) > LOWLVL_DATA_END_ADDRESS)) && \
      ((((addr) < LOWLVL_CODE_START_ADDRESS) || \
      (((addr) + (len) - 1) > LOWLVL_CODE_END_ADDRESS)))) \
   { \
      return HW_ERR_PARAM; \
   }
#endif /* DIRECT_ACCESS_VOLUME */
#else  /* ADDRESS_VALIDATION != TRUE */
#define VALIDATE_ADDRESS(addr, len)
#endif /* ADDRESS_VALIDATION */


/* Returns the previously aligned address on a FLASH_DATA boundary. */
#define ALIGN_ADDRESS(addr) \
   ((DWORD) ((addr) & ((DWORD) ~(sizeof(FLASH_DATA) - 1))))


/*
 * Determines the number of bytes the address is off from being aligned.
 * This macro will return the number of bytes unaligned from the previously
 * aligned address.
 */
#define UNALIGNED_BYTES(addr) \
   ((DWORD) ((addr) & ((DWORD) (sizeof(FLASH_DATA) - 1))))


/* For packet data only: check to see if the argument is properly aligned */
#if (PACKET_DATA == TRUE)
#if (PARAM_CHECK == TRUE)
#define CHECK_ALIGNMENT(addr) \
   if (UNALIGNED_BYTES((DWORD)(addr))) \
   { \
      return HW_ERR_PARAM; \
   }
#else
#define CHECK_ALIGNMENT(addr)
#endif /* PARAM_CHECK */
#endif /* PACKET_DATA */



/* Returns the lesser of the two values passed */
#define GET_MIN(a, b)               (((a) < (b)) ? (a) : (b))



/*
 * To support protection registers, the following values are used to set
 * lock bits, obtain protection register sizes, and obtain lock registers.
 */
#if (ENABLE_PR != FDI_NONE)
#define FLASH_PR_LOCK_REG0    0x80
#define FLASH_PR_LOCK_REG1    0x89

#if (FLASH_PAIRED != TRUE)
#define FLASH_PR_64BIT_SIZE   ((64 >> 3) >> (sizeof(FLASH_DATA) >> 1))
#define FLASH_PR_128BIT_SIZE  ((128 >> 3) >> (sizeof(FLASH_DATA) >> 1))
#else /* FLASH_PAIRED == TRUE */
#define FLASH_PR_64BIT_SIZE   (((64 >> 3) >> (sizeof(FLASH_DATA) >> 1)) << 1)
#define FLASH_PR_128BIT_SIZE  (((128 >> 3) >> (sizeof(FLASH_DATA) >> 1)) << 1)
#endif /* FLASH_PAIRED */

#define FLASH_PR_LOCK0_VALUE        CREATE_COMMAND(0xFFFD)
#define FLASH_PR_LOCK1_VALUE        CREATE_COMMAND(0xFFFE)
#define FLASH_PR_LOCK2_VALUE        CREATE_COMMAND(0xFFFD)
#define FLASH_PR_LOCK3_VALUE        CREATE_COMMAND(0xFFFB)
#define FLASH_PR_LOCK4_VALUE        CREATE_COMMAND(0xFFF7)
#define FLASH_PR_LOCK5_VALUE        CREATE_COMMAND(0xFFEF)
#define FLASH_PR_LOCK6_VALUE        CREATE_COMMAND(0xFFDF)
#define FLASH_PR_LOCK7_VALUE        CREATE_COMMAND(0xFFBF)
#define FLASH_PR_LOCK8_VALUE        CREATE_COMMAND(0xFF7F)
#define FLASH_PR_LOCK9_VALUE        CREATE_COMMAND(0xFEFF)
#define FLASH_PR_LOCK10_VALUE       CREATE_COMMAND(0xFDFF)
#define FLASH_PR_LOCK11_VALUE       CREATE_COMMAND(0xFBFF)
#define FLASH_PR_LOCK12_VALUE       CREATE_COMMAND(0xF7FF)
#define FLASH_PR_LOCK13_VALUE       CREATE_COMMAND(0xEFFF)
#define FLASH_PR_LOCK14_VALUE       CREATE_COMMAND(0xDFFF)
#define FLASH_PR_LOCK15_VALUE       CREATE_COMMAND(0xBFFF)
#define FLASH_PR_LOCK16_VALUE       CREATE_COMMAND(0x7FFF)

#define GET_PR_LOCK_REG(reg)  ((reg) ? FLASH_PR_LOCK_REG1 : FLASH_PR_LOCK_REG0)
#endif /* ENABLE_PR */



/*#############################################################################
 *# Function Pointers
 *###########################################################################*/

/* LowLvlWrite Function Pointer */
/* E.5.0.652 Begin */
#if (BUFFER_SIZE > 0)
typedef HW_ERROR (*LLWRITE_FUNCPTR)(volatile FLASH_DATA *, FLASH_DATA *,
                                    DWORD);
extern HW_ERROR LowLvlWrite(volatile FLASH_DATA *, FLASH_DATA *, DWORD);
#else
typedef HW_ERROR (*LLWRITE_FUNCPTR)(volatile FLASH_DATA *, FLASH_DATA *);
extern HW_ERROR LowLvlWrite(volatile FLASH_DATA *, FLASH_DATA *);
#endif
/* E.5.0.652 End */
static LLWRITE_FUNCPTR PtrLowLvlWrite;

/* LowLvlEraseBlock Function Pointer */
typedef HW_ERROR (*LLERASE_FUNCPTR)(volatile FLASH_DATA_PTR);
extern HW_ERROR LowLvlEraseBlock(volatile FLASH_DATA_PTR);
static LLERASE_FUNCPTR PtrLowLvlEraseBlock;

/* LowLvlReadStat Function Pointer */
typedef FLASH_DATA (*LLREADSTAT_FUNCPTR)(volatile FLASH_DATA_PTR);
extern FLASH_DATA LowLvlReadStat(volatile FLASH_DATA_PTR);
static LLREADSTAT_FUNCPTR PtrLowLvlReadStat;

/* LowLvlClearStat Function Pointer */
typedef void (*LLCLEARSTAT_FUNCPTR)(volatile FLASH_DATA_PTR);
extern void LowLvlClearStat(volatile FLASH_DATA_PTR);
static LLCLEARSTAT_FUNCPTR PtrLowLvlClearStat;

/* LowLvlLock Function Pointer */
#if (BLOCK_LOCK_SUPPORT == TRUE)
typedef HW_ERROR (*LLLOCK_FUNCPTR)(volatile FLASH_DATA_PTR, FLASH_DATA_PTR,
                                   HW_CMD);
extern HW_ERROR LowLvlLock(volatile FLASH_DATA_PTR, FLASH_DATA_PTR, HW_CMD);
static LLLOCK_FUNCPTR PtrLowLvlLock;
#endif

/* LowLvlProtectReg Function Pointer */
#if (ENABLE_PR != FDI_NONE)
typedef HW_ERROR (*LLPR_FUNCPTR)(volatile FLASH_DATA_PTR, FLASH_DATA_PTR,
                                 HW_CMD);
extern HW_ERROR LowLvlProtectReg(volatile FLASH_DATA_PTR, FLASH_DATA_PTR,
                                 HW_CMD);
static LLPR_FUNCPTR PtrLowLvlProtectReg;
#endif

/* LowLvlWritePacket Function Pointer */
#if ((PACKET_DATA == TRUE) && (BUFFER_SIZE == 0))
typedef HW_ERROR (*LLWRITEPACKET_FUNCPTR)(DWORD_PTR, DWORD_PTR, DWORD_PTR);
extern HW_ERROR LowLvlWritePacket(DWORD_PTR, DWORD_PTR, DWORD_PTR);
static LLWRITEPACKET_FUNCPTR PtrLowLvlWritePacket;
#endif /* BUFFER_SIZE */

#if (RELOCATE_CODE == TRUE)
extern void LowLvlEnd(void);
#endif


#if (CONSISTENT_ACCESS_TIME == TRUE)
extern DATA_LOOKUP_PTR FDI_DataLookupPtrTable[];
#endif /* CONSISTENT_ACCESS_TIME */
/*extern SEM_MTX_ID  SEM_LookupTable;*/
extern LOGICAL_BLOCK FDI_LogicalBlockTable[];
extern SEM_MTX_ID  SEM_BlockTable;

/*
 *### Local Functions
 *#########################
 */



/*
 *### Global Declarations
 *#########################
 */

#if (TIME_MONITOR_ENABLED == TRUE)
const DWORD LowLvlTimeNeeded = GET_MINIMUM_TICKS;
#endif /* TIME_MONITOR_ENABLED */


/* Flash Device Semaphores */
extern SEM_MTX_ID SEM_FlashWrite;
/* E5.3.875 START */
/*#if (DIRECT_ACCESS_VOLUME == TRUE)*/
extern SEM_MTX_ID SEM_FlashErase;
/*#endif  /DIRECT_ACCESS_VOLUME */
/* E5.3.875 END*/


/*
 *### Global Functions
 *#########################
 */

#if (RELOCATE_CODE == TRUE)
/*#############################################################################
  ### FlashDevInit (Relocatable Code Version)
  ###
  ### DESCRIPTION:
  ###   Initializes the pointers used by the flash device functions.  Though
  ###   the flash device functions do not check, this function must be
  ###   called before any of the flash device functions can be called.
  ###
  ### PARAMETERS:
  ###    IN:  address (DWORD) - The physical address to where the low-level
  ###          functions will be relocated.
  ###    OUT:
  ###
  ### RETURNS:
  ###   HW_ERR_NONE.
  ###
 */

HW_ERROR FlashDevInit(DWORD address)
{
   BYTE_PTR dst_ptr = (BYTE_PTR) address;
   BYTE_PTR src_ptr = (BYTE_PTR) LowLvlWrite;
   WORD size = (WORD) ((DWORD) LowLvlEnd - (DWORD) LowLvlWrite);


   HARDWARE_INITIALIZE;
   MemoryMove(dst_ptr, src_ptr, size);

   /* Functions that must be relocated */
   PtrLowLvlWrite = (LLWRITE_FUNCPTR) address;
   PtrLowLvlEraseBlock = (LLERASE_FUNCPTR) (address +
                         ((DWORD) LowLvlEraseBlock - (DWORD) LowLvlWrite));
   PtrLowLvlReadStat = (LLREADSTAT_FUNCPTR) (address +
                       ((DWORD) LowLvlReadStat - (DWORD) LowLvlWrite));
   PtrLowLvlClearStat = (LLCLEARSTAT_FUNCPTR) (address +
                        ((DWORD) LowLvlClearStat - (DWORD) LowLvlWrite));

   /* Relocated functions based on configuration */
#if (BLOCK_LOCK_SUPPORT == TRUE)
   PtrLowLvlLock = (LLLOCK_FUNCPTR) (address + ((DWORD) LowLvlLock -
                   (DWORD) LowLvlWrite));
#endif /* BLOCK_LOCK_SUPPORT */

#if (ENABLE_PR != FDI_NONE)
   PtrLowLvlProtectReg = (LLPR_FUNCPTR) (address + ((DWORD) LowLvlProtectReg -
                         (DWORD) LowLvlWrite));
#endif /* ENABLE_PR */

#if ((PACKET_DATA == TRUE) && (BUFFER_SIZE == 0))
   PtrLowLvlWritePacket = (LLWRITEPACKET_FUNCPTR) (address +
                          ((DWORD) LowLvlWritePacket - (DWORD) LowLvlWrite));
#endif /* (PACKET_DATA == TRUE) && (BUFFER_SIZE == 0) */

   return HW_ERR_NONE;
}



#else /* RELOCATE_CODE != TRUE */
/*#############################################################################
  ### FlashDevInit (Non-Relocatable Code Version)
  ###
  ### DESCRIPTION:
  ###   Initializes the pointers used by the flash device functions.  Though
  ###   the flash device functions do not check, this function must be
  ###   called before any of the flash device functions can be called.
  ###
  ### PARAMETERS:
  ###    IN:  address (DWORD) - The physical address to where the low-level
  ###          functions will be relocated.  For debugging purposes, it is
  ###          ignored.
  ###    OUT:
  ###
  ### RETURNS:
  ###   HW_ERR_NONE.
  ###
 */

HW_ERROR FlashDevInit()
{
   HARDWARE_INITIALIZE;

   /* Required funtions */
   PtrLowLvlWrite       = (LLWRITE_FUNCPTR) LowLvlWrite;
   PtrLowLvlEraseBlock  = (LLERASE_FUNCPTR) LowLvlEraseBlock;
   PtrLowLvlReadStat    = (LLREADSTAT_FUNCPTR) LowLvlReadStat;
   PtrLowLvlClearStat   = (LLCLEARSTAT_FUNCPTR) LowLvlClearStat;

   /* Assign based on configuration */
#if (BLOCK_LOCK_SUPPORT == TRUE)
   PtrLowLvlLock        = (LLLOCK_FUNCPTR) LowLvlLock;
#endif /* BLOCK_LOCK_SUPPORT */

#if (ENABLE_PR != FDI_NONE)
   PtrLowLvlProtectReg  = (LLPR_FUNCPTR) LowLvlProtectReg;
#endif /* ENABLE_PR */

#if ((PACKET_DATA == TRUE) && (BUFFER_SIZE == 0))
   PtrLowLvlWritePacket = (LLWRITEPACKET_FUNCPTR) LowLvlWritePacket;
#endif /* (PACKET_DATA == TRUE) && (BUFFER_SIZE == 0) */

   return HW_ERR_NONE;
}
#endif /* RELOCATE_CODE */



/*#############################################################################
  ### FlashDevCompatCheck
  ###