fdi_mpll.c

Flash file system

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

#if (((BLOCK_LOCK_SUPPORT == TRUE) && (ENABLE_NONFDI_BLOCKLOCKING == TRUE)) \
    || (ENABLE_PR != FDI_NONE))
typedef FLASH_DATA (*LLREADSTAT_FUNCPTR)(volatile FLASH_DATA_PTR);
extern FLASH_DATA LowLvlReadStat(volatile FLASH_DATA_PTR);
static LLREADSTAT_FUNCPTR PtrLowLvlReadStat;
#endif /* (BLOCK_LOCK_SUPPORT && ENABLE_NONFDI_BLOCKLOCKING) || ENABLE_PR */

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

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

#if (RELOCATE_CODE == TRUE)
extern HW_ERROR LowLvlEnd(void);
#endif /* RELOCATE_CODE */
/* Flash Device Semaphores */
extern SEM_MTX_ID SEM_FlashWrite;
#if (DIRECT_ACCESS_VOLUME == TRUE)
extern SEM_MTX_ID SEM_FlashErase;
#endif /* DIRECT_ACCESS_VOLUME */

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



/*#############################################################################
 *# Dual/Multi Partition Macros
 *###########################################################################*/

/* partition states */
/*typedef enum
{
   HW_STATE_READ   = 0,
   HW_STATE_STATUS = 1
} HW_STATE;*/
enum
{
   HW_STATE_READ   = 0,
   HW_STATE_STATUS = 1
};


/* sets partition state */
#define SET_PARTITION_STATE(addr, state) \
   (((addr) & (-sizeof(FLASH_DATA))) | ((DWORD) (state)))

/* gets partition state */
#define GET_PARTITION_STATE(ps) \
   (((ps) & HW_STATE_STATUS) ? HW_STATE_STATUS : HW_STATE_READ)

/* gets partition address */
#define GET_PARTITION_ADDRESS(ps) \
   ((ps) & (-sizeof(FLASH_DATA)))


/* Checks if the partition is ready to be read from */
#if (PARTITIONS != MULTI)
#define CUI_FLASH_STATUS_PARTITION_READY        0x80
#else  /* PARTITIONS == MULTI */
#define CUI_FLASH_STATUS_PARTITION_READY        0x81
#endif /* PARTITIONS */

#define FLASH_STATUS_PARTITION_READY \
   CREATE_COMMAND(CUI_FLASH_STATUS_PARTITION_READY)

/* E5.0.480 START */
#if (FLASH_PAIRED == TRUE)
#define SHIFT_FACTOR (sizeof(FLASH_DATA) << 2)
#define DEVICE0_MASK ((FLASH_DATA) (ALL_F >> SHIFT_FACTOR))
#define DEVICE1_MASK ((FLASH_DATA) ((ALL_F >> SHIFT_FACTOR) << SHIFT_FACTOR))

#define IS_PARTITION_BUSY(fp) \
   ((((*(fp) & DEVICE0_MASK) & FLASH_STATUS_PARTITION_READY) == 0) || \
    (((*(fp) & DEVICE1_MASK) & FLASH_STATUS_PARTITION_READY) == 0))
#define RESUME_WRITE_SUSPENDED_FLASH(fp) \
   if ((*(fp) & DEVICE0_MASK) & FLASH_STATUS_WRITE_SUSPENDED) \
   { \
      *(fp) = ((FLASH_COMMAND_STATUS & DEVICE1_MASK) | \
               (FLASH_COMMAND_RESUME & DEVICE0_MASK)); \
   } \
   if ((*(fp) & DEVICE1_MASK) & FLASH_STATUS_WRITE_SUSPENDED) \
   { \
      *(fp) = ((FLASH_COMMAND_STATUS & DEVICE0_MASK) | \
               (FLASH_COMMAND_RESUME & DEVICE1_MASK)); \
   } \
   *(fp) = FLASH_COMMAND_STATUS

#else  /* FLASH_PAIRED != TRUE */
#define IS_PARTITION_BUSY(fp) \
   ((*(fp) & FLASH_STATUS_PARTITION_READY) == 0)
#define RESUME_WRITE_SUSPENDED_FLASH(fp) \
   *(fp) = FLASH_COMMAND_RESUME; \
   *(fp) = FLASH_COMMAND_STATUS
#endif /* FLASH_PAIRED */
/* E5.0.480 END */

/* Stores the current block address and the state of the partition */
static DWORD CurrentFlashState =
   SET_PARTITION_STATE(LOWLVL_DATA_START_ADDRESS, HW_STATE_READ);



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

#if (BUFFER_SIZE > 0)
/*#############################################################################
  ### WriteToFlash (Buffered Version)
  ###
  ### DESCRIPTION:
  ###   Writes data to flash and performs error checking before returning.
  ###
  ### PARAMETERS:
  ###    IN:  dst_ptr (FLASH_DATA_PTR) - A pointer to the data destination.
  ###         src_ptr (FLASH_DATA_PTR) - A pointer to the data source.
  ###         size (DWORD) - The number of FLASH_DATA units to write.
  ###    OUT:
  ###
  ### RETURNS:
  ###   If any portion of the data is not written successfully, the function
  ###   returns HW_ERR_WRITE; otherwise, the function returns HW_ERR_NONE.
  ###
 */

static HW_ERROR WriteToFlash(volatile FLASH_DATA *flash_ptr,
                             const    FLASH_DATA *ram_ptr,
                             DWORD size)
{
   FLASH_DATA buffer_size;
   DWORD size_to_write;
   DWORD i;

   DWORD key0, key1;
   HW_ERROR status = HW_ERR_NONE;


   while (size > 0)
   {
      /* not enough data, use single data program */
      if (size == 1)
      {
         DISABLE_INTERRUPTS(key0, key1);
         UNLOCK_BLOCK(flash_ptr);
         *flash_ptr = FLASH_COMMAND_WRITE;
         *flash_ptr = *ram_ptr;
         mDEBUG_RESET_WRITE();
         ENABLE_INTERRUPTS(key0, key1);

         /* increment ram pointer and decrement size */
         ram_ptr++;
         size--;
      }

      /* enough data is present, use hardware buffer */
      else
      {
         /* determine the size of the buffer */
         size_to_write = GET_MIN(size, BUFFER_SIZE / sizeof(FLASH_DATA));
         buffer_size = BUFFER_SIZE_TO_WRITE(size_to_write);

         /* wait until buffer is ready */
         DISABLE_INTERRUPTS(key0, key1);
         UNLOCK_BLOCK(flash_ptr);
         do
         {
            *flash_ptr = FLASH_COMMAND_WRITE_BUFFER;
         } while ((*flash_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY);

         /* send size of data and fill buffer */
         *flash_ptr = buffer_size;
         for (i = 0; i < size_to_write; i++)
         {
            *flash_ptr = *ram_ptr;
            flash_ptr++;
            ram_ptr++;
         }

         /* make sure pointer is in the same block and commit buffer */
         flash_ptr--;
         *flash_ptr = FLASH_COMMAND_CONFIRM;
         mDEBUG_RESET_WRITE();
         ENABLE_INTERRUPTS(key0, key1);

         /* decrement size */
         size -= size_to_write;
      }

      /* wait until flash is done */
      while ((*flash_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY)
      {
      }

      /* Lock the block */
#if ((BLOCK_LOCK_SUPPORT == TRUE) && (ENABLE_FDI_BLOCKLOCKING == TRUE))
      DISABLE_INTERRUPTS(key0, key1);
      LOCK_BLOCK(flash_ptr);
      ENABLE_INTERRUPTS(key0, key1);
#endif

      /* check for errors */
      if (*flash_ptr & FLASH_STATUS_ERROR)
      {
         *flash_ptr = FLASH_COMMAND_CLEAR;
         status = HW_ERR_WRITE;
         break;
      }

      /*
       * if a write is allowed to span blocks, uncomment the following
       * line of code to guarantee that the data, not status, will be read
       * on future reads
       */
      /* *flash_ptr = FLASH_COMMAND_READ; */

      /* increment flash pointer */
      flash_ptr++;
   }

   return status;
}



#else /* BUFFER_SIZE == 0 */
/*#############################################################################
  ### WriteToFlash (Non-Buffered Version)
  ###
  ### DESCRIPTION:
  ###   Writes data to flash and performs error checking before returning.
  ###
  ### PARAMETERS:
  ###    IN:  dst_ptr (FLASH_DATA_PTR) - A pointer to the data destination.
  ###         src_ptr (FLASH_DATA_PTR) - A pointer to the data source.
  ###         size (DWORD) - The number of FLASH_DATA units to write.
  ###    OUT:
  ###
  ### RETURNS:
  ###   If any portion of the data is not written successfully, the function
  ###   returns HW_ERR_WRITE; otherwise, the function returns HW_ERR_NONE.
  ###
 */

static HW_ERROR WriteToFlash(volatile FLASH_DATA *flash_ptr,
                             const    FLASH_DATA *ram_ptr,
                             DWORD size)
{
   DWORD key0, key1;
   HW_ERROR status = HW_ERR_NONE;


   while (size > 0)
   {
      /* program flash */
      DISABLE_INTERRUPTS(key0, key1);
      UNLOCK_BLOCK(flash_ptr);
      *flash_ptr = FLASH_COMMAND_WRITE;
      *flash_ptr = *ram_ptr;
      mDEBUG_RESET_WRITE();
      ENABLE_INTERRUPTS(key0, key1);

      /* wait until flash is done */
      while ((*flash_ptr & FLASH_STATUS_READY) != FLASH_STATUS_READY)
      {
      }

      /* lock the block */
#if ((BLOCK_LOCK_SUPPORT == TRUE) && (ENABLE_FDI_BLOCKLOCKING == TRUE))
      DISABLE_INTERRUPTS(key0, key1);
      LOCK_BLOCK(flash_ptr);
      ENABLE_INTERRUPTS(key0, key1);
#endif

      /* check for errors */
      if (*flash_ptr & FLASH_STATUS_ERROR)
      {
         *flash_ptr = FLASH_COMMAND_CLEAR;
         status = HW_ERR_WRITE;
         break;
      }

      /*
       * if a write is allowed to span blocks, uncomment the following
       * line of code to guarantee that the data, not status, will be read
       * on future reads
       */
      /* *flash_ptr = FLASH_COMMAND_READ; */

      /* update pointers */
      flash_ptr++;
      ram_ptr++;
      size--;
   }

   return status;
}
#endif /* BUFFER_SIZE */



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



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

#if (RELOCATE_CODE == TRUE)
/*#############################################################################
  ### FlashDevInit (Relocate 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)
{
#if (((BLOCK_LOCK_SUPPORT == TRUE) && (ENABLE_NONFDI_BLOCKLOCKING == TRUE)) \
    || (ENABLE_PR != FDI_NONE))
   BYTE_PTR dst_ptr = (BYTE_PTR) address;
   BYTE_PTR src_ptr;
   WORD size;
#endif /* OPTIONAL_FEATURES */