fdi_lowl.h

Flash file system

/*#############################################################################
 *# 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;


#if (FLASH_DEV_ID == FLASH_DEV_INTEL)	/* added by jjs */
/*#############################################################################
 *# 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)

#elif (FLASH_DEV_ID == FLASH_DEV_AMD)	/* added by jjs */

#include "amdflash.h"

#elif (FLASH_DEV_ID == FLASH_LRS1815A)	/* added by tanyc */
#include "wizflash.h"

#else /* FLASH_DEV_ID */		/* added by jjs */

#error You must define the FLASH_DEV_ID macro before compiling this file

#endif /* FLASH_DEV_ID */			/* added by jjs */

/*#############################################################################
 *### Enumerations
 *###########################################################################*/

/* 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;


/* 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 */



/*****************************************************************************
* $Log: fdi_lowl.h $
* Revision 1.3  2002/12/21 01:41:03  Bing
* Check in for VTC
* Revision 1.3  2002/12/19 15:12:25  jjs
* Initial revision.
*****************************************************************************/