scanvat.c

intel的一个高效率FLASH文件系统。思路很好

   WORD     *VATEntry;        /* VSB allocation table entry value */
   DWORD    FlashAddr;        /* Physical flash address */
   WORD     RetVal;
   extern MEMORY_STATUS status[];     /* GlobalMediaStatistics: */
   extern MEMORY_STATUS *status_ptr;  /* GlobalMediaStatistics: */


   status_ptr=&status[ComponentID];   /* GlobalMediaStatistics: */


   /* loop through all blocks */

   do
   {
      if( (( bi != SpareBlock[ComponentID] ) && (Entry == MAXIMUM_VSB+2)) ||
         ( Entry != (MAXIMUM_VSB+2) ) )
      {
         FlashAddr = CalculateFlashAddr( ComponentID, /* calculate physical */
                                         bi,          /* address of block */
                                         sizeof(vi) );
         VATEntry = (WORD *) VSBbuffer;        /* point to first VAT entry */
         /* read VAT entry */
         /*E2.3.41,Added VAT_SIZE_VSB-1 after VSB_PER_BLOCK*/
         if ((RetVal = FlashDevRead(FlashAddr, ((VSB_PER_BLOCK -(VAT_SIZE_VSB-1))* sizeof(vi)),
             (BYTE *)VATEntry )) != ERR_NONE)
            return (RetVal);

         vi = 1;                                /* set VAT count */
         do                                     /* loop through all VATs */
         {
            if(Entry != (MAXIMUM_VSB+2))
            {
               if( *VATEntry == Entry )  /* if it's what we're look'n for */
               {
                  FoundIt = TRUE;
                  break;                            /* exit loop */
               }
            }
            else /* CountVSB  and update global mediastatistics variable */
            {
               if( *VATEntry == VSB_FREE )          /* if it's free */
               {
                  ++status_ptr->clean_sectors; /* count free sectors */
               }
               else if((*VATEntry & VSB_DISCARD_MASK) == 0)
               {
                  ++status_ptr->dirty_sectors;    /* count dirty sectors */
               }
               else
               {
                  ++status_ptr->valid_sectors;     /* count valid sectors */
               }
            }
            VATEntry++;
          /*E2.3.41, Added -VAT_SIZE_VSB-1 after VSB_PER_BLOCK*/  
         } while( ++vi < (VSB_PER_BLOCK-(VAT_SIZE_VSB-1)) );
      }
      if( FoundIt )
      {
         break;
      }
   } while( ++bi < BLOCK_COUNT );

   if( FoundIt == FALSE )                   /* find what we're looking for? */
   {
      return ( 0 );                        /* nope, return value 0 */
   }
   /*E2.3.49*/
   return( CalculateFlashAddr( ComponentID, /* calculate physical */
	                       bi,          /* address of block */
	                      (vi * 2 )));
   /*E2.3.49*/	                      
}

/****************************************************************************
*
*     ScanVAT -- Scan VAT for valid entries
*
*     ENTRY -
*        BYTE -   Flash component block is in
*        BYTE -   Block to scan
*
*     EXIT -
*        WORD -   ERR_NONE      ERR_WRITE
*
*****************************************************************************/

WORD ScanVAT( BYTE ComponentID,  /* Component number to search */
              BYTE BlockID )     /* Block number to search */
{
   WORD     vi;               /* VAT counter */
   WORD     VATEntry;         /* VAT entry value */
   DWORD    FlashAddr;        /* Physical flash address */
   WORD     PrevEntry;        /* Previous VSB VAT entry */
   DWORD    PrevAddr;         /* Previous VSB physical address */
   WORD     RetVal;

   FlashAddr = CalculateFlashAddr( ComponentID, /* get physical address */
                                    BlockID,     /* of first VAT entry */
                                    0 );
   FlashAddr += sizeof( VATEntry );
   vi = 1;                 /* set up VAT counter */
   do
   {
      /* read VAT entry */
      if ((RetVal = FlashDevRead(FlashAddr, sizeof(VATEntry), (BYTE *)&VATEntry))
          != ERR_NONE)
         return (RetVal);

      /* incomplete allocation? */
      if( (VATEntry & VSB_VAT_FLAGS) == VSB_ALLOCATING_MASK )
      {

         /* prepare discard for PLR */
         VATEntry &= VSB_PLR_DISCARDED;
#if PLR_TESTING
         if (PowerLossFlags.breakpoint_number == PLR_BP13)
            PowerLossFlags.current_iteration++;
#endif
         if ((FlashDevWrite(FlashAddr, sizeof(VATEntry),
             (BYTE *)&VATEntry)) != ERR_NONE)
         {
            return( ERR_WRITE ); /* fail if write error */
         }
         /* discard VSB */
         VATEntry &= VSB_DISCARDED;
#if PLR_TESTING
         if (PowerLossFlags.breakpoint_number == PLR_BP14)
            PowerLossFlags.current_iteration++;
#endif
         if ((FlashDevWrite(FlashAddr, sizeof(VATEntry),
                            (BYTE *) &VATEntry)) != ERR_NONE)
         {
            return( ERR_WRITE ); /* give up if write error */
         }
      }
      /* previous not discarded? */

      else if (((VATEntry & VSB_VAT_FLAGS) == VSB_ALLOCATED_MASK)
#if MLC_DEVICE
               ||((VATEntry & VSB_VAT_FLAGS) == VSB_MLC_ALLOCATED_MASK )
#endif
               ) /* end else if */
      {
         PrevAddr = SearchForEntry(ComponentID, (VATEntry & VSB_VALID));
         if (PrevAddr != 0L)
         {
            /* Discard previous VSB */
            if ((FlashDevRead(PrevAddr, sizeof(PrevEntry), (BYTE *)&PrevEntry)) == ERR_NONE )
               PrevEntry &= VSB_DISCARDED;
#if PLR_TESTING
            if (PowerLossFlags.breakpoint_number == PLR_BP15)
               PowerLossFlags.current_iteration++;
#endif
            if ((FlashDevWrite(PrevAddr, sizeof(PrevEntry), (BYTE *)&PrevEntry)) != ERR_NONE )
            {
               return( ERR_WRITE ); /* give up if write error */
            }
         }

         /* Mark current VSB as valid */
         VATEntry &= VSB_VALID;
#if PLR_TESTING
         if (PowerLossFlags.breakpoint_number == PLR_BP16)
            PowerLossFlags.current_iteration++;
#endif
         if ((FlashDevWrite(FlashAddr, sizeof(VATEntry), (BYTE *)&VATEntry)) != ERR_NONE )
         {
            return( ERR_WRITE );
         }
      }
      /* if it was in the middle of discarding, complete discard */
      else if (((VATEntry & VSB_VAT_FLAGS ) != VSB_DISCARDED) &&
               !(VATEntry &  VSB_DISCARD_MASK))
      {
         VATEntry &= VSB_DISCARDED;
#if PLR_TESTING
         if (PowerLossFlags.breakpoint_number == PLR_BP17)
            PowerLossFlags.current_iteration++;
#endif
         if ((FlashDevWrite(FlashAddr, sizeof(VATEntry),
             (BYTE *)&VATEntry )) != ERR_NONE )
         {
            return( ERR_WRITE ); /* give up if write error */
         }
      }
      FlashAddr += sizeof(VATEntry);    /* point to next VAT entry */
      /*E2.3.41, Added -VAT_SIZE_VSB-1 after VSB_PER_BLOCK*/  
   } while (++vi < (VSB_PER_BLOCK-(VAT_SIZE_VSB-1)));
   
   return( ERR_NONE );
}