fm_flt.c

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

/*
##############################################################################
### Intel Confidential
### Copyright (c) Intel Corporation 2002
### All Rights Reserved.
### --------------------------------------------------------------------------
### Project: Flash Data Integrator (FDI)
###
### Module: fm_flt.c - The File Manager File Lookup Table
###
### $Archive: /FDI/SRC/FM_ENH/fm_flt.c $
### $Revision: 17 $
### $Date: 3/15/04 6:43p $
### $Author: Hwang10 $
###
### $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.                             
 *****************************************************************
 */


/*### Includes
 *######################### */

#include "fdi_type.h"

#if (FILE_MANAGER == TRUE)
#include "fm_flt.h"
#include "fdi_file.h"

#include "fdi_err.h"
#include "fdi_ext.h"

#define UINT16_MAX   ((UINT16) -1)


/*### External Functions
 *######################### */

extern int FM_CompareStrings(
   const FDI_TCHAR *,
   const FDI_TCHAR *,
   const size_t
   );

extern FDI_TCHAR * FM_CopyString(
   FDI_TCHAR *,
   const FDI_TCHAR *,
   size_t
   );

extern size_t FM_GetStringLength(const FDI_TCHAR *);



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

/*
 * the following table is used by ComputeHash() to calculate the CRC32 of a
 * data stream
 */
static const UINT32 crctab[256] =
{
   0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B,
   0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61,
   0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD, 0x4C11DB70, 0x48D0C6C7,
   0x4593E01E, 0x4152FDA9, 0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75,
   0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3,
   0x709F7B7A, 0x745E66CD, 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039,
   0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58, 0xBAEA46EF,
   0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D,
   0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49, 0xC7361B4C, 0xC3F706FB,
   0xCEB42022, 0xCA753D95, 0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1,
   0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, 0x34867077, 0x30476DC0,
   0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072,
   0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16, 0x018AEB13, 0x054BF6A4,
   0x0808D07D, 0x0CC9CDCA, 0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE,
   0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08,
   0x571D7DD1, 0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
   0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B, 0xBB60ADFC,
   0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6,
   0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A, 0xE0B41DE7, 0xE4750050,
   0xE9362689, 0xEDF73B3E, 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2,
   0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34,
   0xDC3ABDED, 0xD8FBA05A, 0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637,
   0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB, 0x4F040D56, 0x4BC510E1,
   0x46863638, 0x42472B8F, 0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53,
   0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5,
   0x3F9B762C, 0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF,
   0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, 0xF12F560E, 0xF5EE4BB9,
   0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B,
   0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD,
   0xCDA1F604, 0xC960EBB3, 0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7,
   0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71,
   0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3,
   0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640, 0x4E8EE645, 0x4A4FFBF2,
   0x470CDD2B, 0x43CDC09C, 0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8,
   0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24, 0x119B4BE9, 0x155A565E,
   0x18197087, 0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
   0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D, 0x2056CD3A,
   0x2D15EBE3, 0x29D4F654, 0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0,
   0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C, 0xE3A1CBC1, 0xE760D676,
   0xEA23F0AF, 0xEEE2ED18, 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4,
   0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662,
   0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668,
   0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4
};


/*
 * The FileLookup structure contains the information needed to translate
 * a File Manager file to a Data Manager Parameter ID
 */

typedef struct tagFileLookup
{
   UINT32   Key;
   UINT16   Id;
   UINT16   Reserved;
} FileLookup;


/* The File Lookup Table for File Manager */
static FileLookup FileLookupTable[NUM_FILES];


/* The number of files currently in the File Lookup Table */
static UINT16 NumFilesInFlt = 0;


/*
 * For functions that scan the File Lookup Table, contains the current index
 * into the table
 */
static UINT16 IndexIntoFlt = 0;
/* E.5.2.870 BEGIN */
static UINT16 NextIndexIntoFlt = 0;
/* E.5.2.870 END */



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

/*****************************************************************************
 *
 * GetASingleEntry
 *
 * DESCRIPTION:
 *    Finds a single entry in the table passed using the key specified.  It
 *    does not continue to search the table once it finds a matching entry.
 *
 * PARAMETERS:
 *    IN    key            The key base the search on.
 *          table          A pointer to the table to scan.
 *          num_entries    The number of entries in the table being searched.
 *    OUT   index          The index of the first entry found with a matching
 *                         key.  This value is undefined if the table does
 *                         not contain any entries with the corresponding key.
 *
 * RETURNS:
 *    If an entry is found that has a matching entry, the function returns
 *    FLT_ErrorNone.  If no entry contains the key specified, the function
 *    returns FLT_ErrorEntryDoesNotExist.
 *
 * ASSUMPTIONS:
 *    The table's entries are in sorted order using the key data member as
 *    the value to sort on.
 *
 ****************************************************************************/

static FLT_Error GetASingleEntry(
   UINT16 *             index,
   const UINT32         key,
   const FileLookup *   table,
   const UINT16         num_entries
   )
{
   UINT16 lower_index;
   UINT16 upper_index;
   UINT16 mid_index;

   FLT_Error error = FLT_ErrorEntryDoesNotExist;


   /* if the table contains at least one entry */
   if (num_entries != 0)
   {
      /*
       * perform a binary search on the table, searching for the key
       * specified
       */
      lower_index = 0;
      upper_index = num_entries - 1;

      /* E5.1.768 START */
      /*
       * The function makes use of unsigned numbers, make sure that the
       * values of the indices are not being overflowed.  Since only one
       * of the indices can be modified one at a time and the the case of
       * the two being equal is checked later, there is no possibility of
       * an overflow occurring.
       */
      while (lower_index < upper_index)
      /* E5.1.768 END */
      {
         /*
          * find the midpoint by taking the average of the indices:
          * instead of dividing by 2, perform the same operation by shifting
          * the value right one bit - this is more efficient for the cpu
          */
         mid_index = (upper_index + lower_index) >> 1;

         if (table[mid_index].Key < key)
         {
            lower_index = mid_index + 1;
         }
         else if (table[mid_index].Key > key)
         {
/* E.5.2.869 BEGIN */
             if( mid_index != 0 )
             {
                upper_index = mid_index - 1;
             }
             else
             {
                upper_index = 0;
             }
/* E.5.2.869 END */
         }
         else /* table[mid_index].Key == key */
         {
            (*index) = mid_index;
            error    = FLT_ErrorNone;
            break;
         }
      }

      /* E5.1.768 START */
      /*
       * Need to check for the case where the two indices are equal to one
       * another.  If they are and the index they refer to contains the key
       * being searched for, then return that index; otherwise, the function
       * will return FLT_ErrorEntryDoesNotExist.
       */
      if ((lower_index == upper_index) && (table[lower_index].Key == key))
      {
         (*index) = lower_index;
         error    = FLT_ErrorNone;
      }
      /* E5.1.768 END */
   }

   return error;
}


/*****************************************************************************
 *
 * GetEntryRange
 *
 * DESCRIPTION:
 *    Determines the lower and upper bounds of the entries in the table that
 *    have the matching key.
 *
 * PARAMETERS:
 *    IN    key            The key to base the search on.
 *          table          The table to scan.
 *          num_entries    The number of entries in the table being searched.
 *    OUT   lower_bound    The lower bound of the entries that have the
 *                         matching key value.  If no entries have the key
 *                         value specified, this value is undefined.
 *          upper_bound    The upper bound of the entries that have the
 *                         matching key value.  If no entries have the key
 *                         value specified, this value is undefined.
 *
 * RETURNS:
 *    The function returns the total number of entries that have the
 *    corresponding key.
 *
 * ASSUMPTIONS:
 *    The table's entries are in sorted order using the key data member as
 *    the value to sort on.
 *
 ****************************************************************************/

static UINT16 GetEntryRange(
   UINT16 *             lower_bound,
   UINT16 *             upper_bound,
   const UINT32         key,
   const FileLookup *   table,
   const UINT16         num_entries
   )
{
   UINT16   index;
   UINT16   scan_index;

   UINT16      total_entries;
   FLT_Error   error;


   /* determine if a single entry is present */
   error = GetASingleEntry(&index, key, table, num_entries);

   /* if one is, find the range of the key */
   if (error == FLT_ErrorNone)
   {
      /* E5.1.752/760 START */
      /*
       * search for the first entry with a matching key, making sure that
       * the array bounds are not overstepped
       */
      scan_index = index;
      while ((scan_index > 0) && (table[scan_index - 1].Key == key))
      /* E5.1.752/760 END */
      {
         scan_index--;
      }
      (*lower_bound) = scan_index;

      /* E5.1.752/760 START */
      /*
       * search for the last entry with a matching key, making sure that
       * the array bounds are not overstepped
       */
      scan_index = index;
      while ((scan_index < (num_entries - 1)) &&
             (table[scan_index + 1].Key == key))
      /* E5.1.752/760 END */
      {
         scan_index++;
      }
      (*upper_bound) = scan_index;

      /* calculate the total number of entries found */
      total_entries = ((*upper_bound) - (*lower_bound)) + 1;
   }
   else
   {
      /* declare there are no matching entries */
      total_entries = 0;
   }

   return total_entries;
}



/*****************************************************************************
 *
 * ReadFileInfo
 *
 * DESCRIPTION:
 *    Reads the file information structure of the file specified.
 *
 * PARAMETERS:
 *    IN    id             The Data Manager Parameter ID of the file.
 *    OUT   file_info_ptr  The file information structure of the file.
 *
 * RETURNS:
 *    If an error occurred during FDI_Read(), the function returns
 *    FLT_ErrorRead; otherwise, the function returns FLT_ErrorNone.
 *
 * ASSUMPTIONS:
 *    None.
 *
 ****************************************************************************/

static FLT_Error ReadFileInfo(
   FILE_INFO *    file_info_ptr,
   const UINT16   id
   )
{
   COMMAND_CONTROL   fdi_cmd_cntrl;
   ERR_CODE          fdi_status;

   /* create a data manager command control structure for the file info */
   fdi_cmd_cntrl.buffer_ptr = (BYTE *) file_info_ptr;
   fdi_cmd_cntrl.count      = (DWORD) sizeof(FILE_INFO);
   fdi_cmd_cntrl.offset     = (DWORD) 0;
   fdi_cmd_cntrl.identifier = (WORD) id;
   fdi_cmd_cntrl.type       = (BYTE) FILE_SUPPORT_INFO_TYPE;
   fdi_cmd_cntrl.priority   = (BYTE) FDI_MIN_PRIORITY;

   /* read the file info from flash using the data manager */
   fdi_status = FDI_Read(&fdi_cmd_cntrl);

   /* report any error that occurred from the data manager while reading */
   if (fdi_status == ERR_NONE)
   {
      return FLT_ErrorNone;
   }
   else