fdi_lowl.h

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

/* Copyright(R) 2001-2002 Intel Corporation */
/* ############################################################################
 ### Object: Low Level Driver
 ###
 ### Module:
 ###  $Archive: /FDI/SRC/INCLUDE/fdi_lowl.h $
 ###  $Revision: 67 $
 ###  $Date: 3/03/03 12:46a $
 ###  $Author: Xhuang4 $
 ###
 ###$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.                             
 *****************************************************************
 */


#ifndef __FDI_Lowl_h
#define __FDI_Lowl_h


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

#include "fdi_type.h"



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

/*
 * Setting this option to TRUE includes code that performs validation
 * on the address parameter sent to all low-level functions before
 * executing the low-level function.  If the address combined with
 * other parameters will cause an access outside the data partition
 * range (or the code managed area if DAV is enabled), an error
 * is returned.  This assists to ensure that non-FDI (and non-DAV)
 * sections of flash do not become corrupt through use of the
 * low-level functions.
 */
#define ADDRESS_VALIDATION                   FALSE



/*#############################################################################
 *# Interrupt Control Definitions
 *###########################################################################*/

/*
 * A system-specific macro that reads the interrupt pending register to
 * determine if an interrupt has occurred.
 */
#ifndef INTERRUPT_PENDING
#define TIMER1_BIT                           (1 << 4)
#define TIMER2_BIT                           (1 << 5)
#define PCMCIA_A_BIT                         (1 << 6)
#define PCMCIA_B_BIT                         (1 << 7)
#define SERIAL_A_BIT                         (1 << 8)
#define SERIAL_B_BIT                         (1 << 9)

#define INTERRUPT_POLL_MASK \
   (TIMER1_BIT | \
    TIMER2_BIT | \
    PCMCIA_A_BIT | \
    PCMCIA_B_BIT | \
    SERIAL_A_BIT | \
    SERIAL_B_BIT)

#define INTERRUPT_PENDING \
   (*((UINT32 *) IRQ_RAW_STATUS) & INTERRUPT_POLL_MASK)
#endif /* INTERRUPT_PENDING */


/* Allows the low-level to enable task scheduling and system interrupts */
#ifndef ENABLE_INTERRUPTS
#define ENABLE_INTERRUPTS(key0, key1) \
   intUnlock((int) (key0)); \
   (key1) = (key0)
#endif /* ENABLE_INTERRUPTS */


/* Allows the low-level to disable task scheduling and system interrupts */
#ifndef DISABLE_INTERRUPTS
#define DISABLE_INTERRUPTS(key0, key1) \
   (key0) = (DWORD) intLock(); \
   (key1) = (key0)
#endif /* DISABLE_INTERRUPTS */



/*#############################################################################
 *# Time Monitoring Options
 *###########################################################################*/

/*
 * Setting this option to TRUE enables time monitoring to occur in
 * the low-level.  Time monitoring is a mechanism used in systems with
 * predictable interrupts by suspending program/erase commands slightly
 * before an interrupt is to occur.
 */
#define TIME_MONITOR_ENABLED                 FALSE

#if (TIME_MONITOR_ENABLED == TRUE)
/*
 * The minimum number of microseconds of time to allow an erase or program to
 * begin processing.  If this amount of time is not available, the system
 * will wait until after the next scheduled interrupt before beginning the
 * erase or program.
 */
#ifndef MINIMUM_RUN_TIME
#define MINIMUM_RUN_TIME                     25
#endif /* MINIMUM_RUN_TIME */


/*
 * System-specific macro that converts the number of microseconds into a tick
 * count.  The minimum processing time required in ticks.
 */
#ifndef GET_MINIMUM_TICKS
#define GET_MINIMUM_TICKS \
   ((WORD) ((SYS_CPU_FREQ / 1000000) * MINIMUM_RUN_TIME))
#endif /* GET_MINIMUM_TICKS */


/*
 * System-specific macro that determines how much time is available for
 * processing before the next interrupt will occur.  Time is expressed in
 * ticks.
 */
#ifndef TICKS_TILL_NEXT_INTERRUPT
#ifndef SLC_TDMA_PERIOD
#define SLC_TDMA_PERIOD                (4615)
#endif /* SLC_TDMA_PERIOD */

#ifndef SLC_INTERRUPTS_PER_TDMA
#define SLC_INTERRUPTS_PER_TDMA        1
#endif /* SLC_INTERRUPTS_PER_TDMA */

#ifndef SLC_TICKS_PER_SLOT
#define SLC_TICKS_PER_SLOT \
   ((SYS_CPU_FREQ / 1000000) * (SLC_TDMA_PERIOD / SLC_INTERRUPTS_PER_TDMA))
#endif /* SLC_TICKS_PER_SLOT */

#define TICKS_TILL_NEXT_INTERRUPT() \
   ((WORD) (SLC_TICKS_PER_SLOT - *M360_CPM_TCN2(AUX_TMR_BASE)))
#endif /* TICKS_TILL_NEXT_INTERRUPT */


/*
 * System-specific macro to provide a mechanism to wait for the next
 * regularly scheduled interrupt while allowing task scheduling to occur in
 * the background.
 */
#ifndef WAIT_FOR_INTERRUPT
#define WAIT_FOR_INTERRUPT() \
   *M360_CPM_CIMR(AUX_TMR_BASE) &= ~CPIC_CIXR_TMR2; \
   while (((WORD) (*M360_CPM_TER2(AUX_TMR_BASE))) == 0) \
   { \
      ; \
   } \
   *M360_CPM_CIMR(AUX_TMR_BASE) |= CPIC_CIXR_TMR2
#endif /* WAIT_FOR_INTERRUPT */


/*
 * TIME_MONITOR defines the wait time interval during interrupt polling
 * before proceeding.  Interrupts are disabled to check time left until the
 * next periodic interrupt and re-enabled if there is not enough time to
 * allow task switching.  The task is delayed until the next interrupt
 * before re-checking to determine if enough time exists.
 */
#ifndef TIME_MONITOR
#define TIME_MONITOR(key0, key1) \
   for (;;) \
   { \
      DISABLE_INTERRUPTS((key0), (key1)); \
      if (TICKS_TILL_NEXT_INTERRUPT() > LowLvlTimeNeeded) \
      { \
         break; \
      } \
      ENABLE_INTERRUPTS((key0), (key1)); \
      WAIT_FOR_INTERRUPT(); \
   }
#endif /* TIME_MONITOR */
#endif /* TIME_MONITOR_ENABLED */


/*#############################################################################
 *# Hardware Specific Definitions
 *###########################################################################*/

/*
 * For platforms that require hardware initialization before accessing flash,
 * this macro performs the necessary actions that need to occur before the
 * first access to flash.
 */
#ifndef HARDWARE_INITIALIZE
#define HARDWARE_INITIALIZE
#endif /* HARDWARE_INITIALIZE */


/*
 * For platforms that require hardware manipulation before writing/erasing
 * flash, this macro performs the necessary actions that need to occur
 * before writing/erasing flash.
 */
#ifndef HARDWARE_PRECONDITION
#define HARDWARE_PRECONDITION
#endif /* HARDWARE_PRECONDITION */


/*
 * For platforms that require hardware manipulation after writing/erasing
 * flash, this macro performs the necessary actions that need to occur
 * after writing/erasing flash.
 */
#ifndef HARDWARE_POSTCONDITION
#define HARDWARE_POSTCONDITION
#endif /* HARDWARE_POSTCONDITION */



/*#############################################################################
 *# Type Definitions
 *###########################################################################*/
typedef FLASH_DATA_WIDTH   FLASH_DATA;
typedef FLASH_DATA        *FLASH_DATA_PTR;



/*#############################################################################
 *# CUI Flash Command Definitions
 *###########################################################################*/
#define CUI_FLASH_COMMAND_READ               0xFF
#define CUI_FLASH_COMMAND_READ_ID            0x90
#define CUI_FLASH_COMMAND_QUERY              0x98
#define CUI_FLASH_COMMAND_STATUS             0x70
#define CUI_FLASH_COMMAND_CLEAR              0x50
#define CUI_FLASH_COMMAND_WRITE              0x40
#define CUI_FLASH_COMMAND_ERASE              0x20
#define CUI_FLASH_COMMAND_CONFIRM            0xD0
#define CUI_FLASH_COMMAND_SUSPEND            0xB0
#define CUI_FLASH_COMMAND_RESUME             0xD0
#define CUI_FLASH_COMMAND_READ_CFG           0x60
#define CUI_FLASH_COMMAND_RCD                0x03
#define CUI_FLASH_COMMAND_WRITE_PR           0xC0
#define CUI_FLASH_COMMAND_LOCK               0x60
#define CUI_FLASH_COMMAND_LOCK_CONFIRM       0x01
#define CUI_FLASH_COMMAND_UNLOCK_CONFIRM     0xD0
#define CUI_FLASH_COMMAND_LOCKDOWN_CONFIRM   0x2F
#define CUI_FLASH_COMMAND_WRITE_BUFFER       0xE8
#define CUI_FLASH_COMMAND_ABORT              0xFF


/*#############################################################################
 *# CUI Flash Status Definitions
 *###########################################################################*/
#define CUI_FLASH_STATUS_READY               0x80
#define CUI_FLASH_STATUS_ERASE_SUSPENDED     0x40
#define CUI_FLASH_STATUS_WRITE_SUSPENDED     0x04
#define CUI_FLASH_STATUS_ERROR               0x3A



/*
 * If two components make up the data bus, then the command needs to be
 * paired.  If only a single component is present, then pad the command
 * with zeros.
 */
#if (FLASH_PAIRED == TRUE)
#define CREATE_COMMAND(x) \
   (((FLASH_DATA)(x)) | ((FLASH_DATA)(x) << (sizeof(FLASH_DATA) << 2)))
#else  /* !FLASH_PAIRED */
#define CREATE_COMMAND(x)                    ((FLASH_DATA)(x))
#endif /* FLASH_PAIRED */


/*#############################################################################
 *# Flash Command Definitions
 *###########################################################################*/
#define FLASH_COMMAND_READ \
   CREATE_COMMAND(CUI_FLASH_COMMAND_READ)
#define FLASH_COMMAND_READ_ID \
   CREATE_COMMAND(CUI_FLASH_COMMAND_READ_ID)
#define FLASH_COMMAND_QUERY \
   CREATE_COMMAND(CUI_FLASH_COMMAND_QUERY)
#define FLASH_COMMAND_STATUS \
   CREATE_COMMAND(CUI_FLASH_COMMAND_STATUS)
#define FLASH_COMMAND_CLEAR \
   CREATE_COMMAND(CUI_FLASH_COMMAND_CLEAR)
#define FLASH_COMMAND_WRITE \
   CREATE_COMMAND(CUI_FLASH_COMMAND_WRITE)
#define FLASH_COMMAND_ERASE \
   CREATE_COMMAND(CUI_FLASH_COMMAND_ERASE)
#define FLASH_COMMAND_CONFIRM \
   CREATE_COMMAND(CUI_FLASH_COMMAND_CONFIRM)
#define FLASH_COMMAND_SUSPEND \
   CREATE_COMMAND(CUI_FLASH_COMMAND_SUSPEND)
#define FLASH_COMMAND_RESUME \
   CREATE_COMMAND(CUI_FLASH_COMMAND_RESUME)
#define FLASH_COMMAND_READ_CFG \
   CREATE_COMMAND(CUI_FLASH_COMMAND_READ_CFG)
#define FLASH_COMMAND_RCD \
   CREATE_COMMAND(CUI_FLASH_COMMAND_RCD)
#define FLASH_COMMAND_WRITE_PR \
   CREATE_COMMAND(CUI_FLASH_COMMAND_WRITE_PR)
#define FLASH_COMMAND_LOCK \
   CREATE_COMMAND(CUI_FLASH_COMMAND_LOCK)
#define FLASH_COMMAND_LOCK_CONFIRM \
   CREATE_COMMAND(CUI_FLASH_COMMAND_LOCK_CONFIRM)
#define FLASH_COMMAND_UNLOCK_CONFIRM \
   CREATE_COMMAND(CUI_FLASH_COMMAND_UNLOCK_CONFIRM)
#define FLASH_COMMAND_LOCKDOWN_CONFIRM \
   CREATE_COMMAND(CUI_FLASH_COMMAND_LOCKDOWN_CONFIRM)
#define FLASH_COMMAND_WRITE_BUFFER \
   CREATE_COMMAND(CUI_FLASH_COMMAND_WRITE_BUFFER)
#define FLASH_COMMAND_ABORT \
   CREATE_COMMAND(CUI_FLASH_COMMAND_ABORT)


/*#############################################################################
 *# Flash Status Commands
 *###########################################################################*/
#define FLASH_STATUS_READY \
   CREATE_COMMAND(CUI_FLASH_STATUS_READY)
#define FLASH_STATUS_ERASE_SUSPENDED \
   CREATE_COMMAND(CUI_FLASH_STATUS_ERASE_SUSPENDED)
#define FLASH_STATUS_WRITE_SUSPENDED \
   CREATE_COMMAND(CUI_FLASH_STATUS_WRITE_SUSPENDED)
#define FLASH_STATUS_ERROR \
   CREATE_COMMAND(CUI_FLASH_STATUS_ERROR)



/*#############################################################################
 *### Enumerations
 *###########################################################################*/
/* E.5.0.690 Begin */ 
/*move HW_ERROR definition to fdi_err.h*/
/* Hardware Error Values */
/*
typedef enum
{
   HW_ERR_NONE = 0,
   HW_ERR_PARAM,
   HW_ERR_READ,
   HW_ERR_WRITE,
   HW_ERR_ERASE,
   HW_ERR_ABORT,
   HW_ERR_JEDEC,
   HW_ERR_EMPTY_LKUP,
   HW_ERR_SPACE,
   HW_ERR_FLASH_FULL,
   HW_ERR_SYSTEM,
   HW_ERR_SUSPEND,
   HW_ERR_DELETE,
   HW_ERR_NOTRDY,
   HW_ERR_LOCK,
   HW_ERR_COMPAT,
   HW_ERR_PLR_TEST_FAILURE
} HW_ERROR;

*/
/* E.5.0.690 End */ 

/* Hardware Command Values */
typedef enum
{
   HW_CMD_LOCK,
   HW_CMD_LOCKDOWN,
   HW_CMD_UNLOCK,
   HW_CMD_READLOCKSTATUS,
   HW_CMD_READ_PR,
   HW_CMD_WRITE_PR,
   HW_CMD_READ_PR_LOCK,
   HW_CMD_WRITE_PR_LOCK
} HW_CMD;



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

#if (RELOCATE_CODE == TRUE)
HW_ERROR FlashDevInit(DWORD);
#else /* !RELOCATE_CODE */
HW_ERROR FlashDevInit(void);
#endif /* RELOCATE_CODE */

HW_ERROR FlashDevCompatCheck(DWORD, DWORD);
HW_ERROR FlashDevWrite(BYTE_PTR, DWORD, DWORD);
HW_ERROR FlashDevEraseBlock(DWORD);
HW_ERROR FlashDevCopy(DWORD, DWORD, DWORD);
HW_ERROR FlashDevRead(BYTE_PTR, DWORD, DWORD);


#if (BLOCK_LOCK_SUPPORT == TRUE)
HW_ERROR FlashDevLock(FLASH_DATA_PTR, DWORD, HW_CMD);
#endif /* BLOCK_LOCK_SUPPORT */

#if (ENABLE_PR != FDI_NONE)
HW_ERROR FlashDevProtectReg(FLASH_DATA_PTR, FLASH_DATA_PTR, FLASH_DATA_PTR,
                            HW_CMD, BYTE, BYTE);
#endif /* ENABLE_PR */

#if (PACKET_DATA == TRUE)
HW_ERROR FlashDevWritePacket(BYTE_PTR, DWORD, DWORD);
#endif /* PACKET_DATA */

#if (CONSISTENT_ACCESS_TIME == TRUE)
HW_ERROR FlashDevUpdateDLT(DWORD);
#endif

#endif /* __FDI_Lowl_h */